Skip to content

The open alternative to Salesforce, designed for AI.

chore(log) - log one line per API request with actor, endpoint and trace ids (#26269)

Etienne073450d57dda
diff --git a/packages/twenty-server/@types/express.d.ts b/packages/twenty-server/@types/express.d.ts
index 4c92df2bc0c..a074781fea3 100644
--- a/packages/twenty-server/@types/express.d.ts
+++ b/packages/twenty-server/@types/express.d.ts
@@ -27,5 +27,6 @@ declare module 'express-serve-static-core' {
impersonationContext?: RawAuthContext['impersonationContext'];
tokenType?: JwtTokenTypeEnum;
authenticatedAt?: Date;
+ executedRootResolvers?: string[];
}
}
diff --git a/packages/twenty-server/src/app.module.ts b/packages/twenty-server/src/app.module.ts
index 3917827e6f8..8357359e446 100644
--- a/packages/twenty-server/src/app.module.ts
+++ b/packages/twenty-server/src/app.module.ts
@@ -28,6 +28,7 @@ import { MetricsModule } from 'src/engine/core-modules/metrics/metrics.module';
import { DataloaderModule } from 'src/engine/dataloaders/dataloader.module';
import { WorkspaceMetadataVersionModule } from 'src/engine/metadata-modules/workspace-metadata-version/workspace-metadata-version.module';
import { ApiRequestContextMiddleware } from 'src/engine/core-modules/usage/middlewares/api-request-context.middleware';
+import { ApiAccessLogMiddleware } from 'src/engine/middlewares/api-access-log.middleware';
import { CookieSessionCsrfMiddleware } from 'src/engine/middlewares/cookie-session-csrf.middleware';
import { GraphQLHydrateRequestFromTokenMiddleware } from 'src/engine/middlewares/graphql-hydrate-request-from-token.middleware';
import { GraphQLRefuseSuspendedWorkspaceMiddleware } from 'src/engine/middlewares/graphql-refuse-suspended-workspace.middleware';
@@ -112,6 +113,17 @@ export class AppModule {
}
configure(consumer: MiddlewareConsumer) {
+ const loggedApiPaths = Object.values(ApiPath).filter(
+ (apiPath) => apiPath !== ApiPath.Health,
+ );
+
+ consumer.apply(ApiAccessLogMiddleware).forRoutes(
+ ...loggedApiPaths.flatMap((apiPath) => [
+ { path: apiPath, method: RequestMethod.ALL },
+ { path: `${apiPath}/*path`, method: RequestMethod.ALL },
+ ]),
+ );
+
// Before any middleware that authenticates from the session cookie.
consumer
.apply(CookieSessionCsrfMiddleware)
diff --git a/packages/twenty-server/src/engine/api/graphql/direct-execution/hooks/use-direct-execution.hook.ts b/packages/twenty-server/src/engine/api/graphql/direct-execution/hooks/use-direct-execution.hook.ts
index 30696179097..b1be061b8bc 100644
--- a/packages/twenty-server/src/engine/api/graphql/direct-execution/hooks/use-direct-execution.hook.ts
+++ b/packages/twenty-server/src/engine/api/graphql/direct-execution/hooks/use-direct-execution.hook.ts
@@ -6,6 +6,8 @@ import { type Plugin } from 'graphql-yoga';
import { isNull } from '@sniptt/guards';
import { type DirectExecutionService } from 'src/engine/api/graphql/direct-execution/direct-execution.service';
import { classifyTopLevelFields } from 'src/engine/api/graphql/direct-execution/utils/classify-top-level-fields.util';
+import { captureExecutedRootResolvers } from 'src/engine/api/graphql/utils/capture-executed-root-resolvers.util';
+import { extractTopLevelFieldsSafely } from 'src/engine/api/graphql/utils/extract-top-level-fields-safely.util';
import { findOperationDefinition } from 'src/engine/api/graphql/direct-execution/utils/find-operation-definition.util';
import { isSubscriptionOperation } from 'src/engine/api/graphql/direct-execution/utils/is-subscription-operation.util';
import { type FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
@@ -37,6 +39,13 @@ export function useDirectExecution(
return;
}
+ const topLevelFields = extractTopLevelFieldsSafely(
+ document,
+ operationName,
+ );
+
+ captureExecutedRootResolvers({ request: req, topLevelFields });
+
const operationDefinition = findOperationDefinition(
document,
operationName,
@@ -59,7 +68,7 @@ export function useDirectExecution(
}
const { hasIntrospectionFields, hasWorkspaceFields, hasCoreFields } =
- classifyTopLevelFields(document, operationName, workspaceResolverNames);
+ classifyTopLevelFields(topLevelFields, workspaceResolverNames);
if (hasCoreFields && hasWorkspaceFields) {
const error = new UserInputError(
diff --git a/packages/twenty-server/src/engine/api/graphql/direct-execution/utils/__tests__/classify-top-level-fields.util.spec.ts b/packages/twenty-server/src/engine/api/graphql/direct-execution/utils/__tests__/classify-top-level-fields.util.spec.ts
index b87024425ce..5ffa953c99c 100644
--- a/packages/twenty-server/src/engine/api/graphql/direct-execution/utils/__tests__/classify-top-level-fields.util.spec.ts
+++ b/packages/twenty-server/src/engine/api/graphql/direct-execution/utils/__tests__/classify-top-level-fields.util.spec.ts
@@ -1,6 +1,7 @@
import { parse } from 'graphql';
import { classifyTopLevelFields } from 'src/engine/api/graphql/direct-execution/utils/classify-top-level-fields.util';
+import { graphQLExtractTopLevelFields } from 'src/engine/api/graphql/direct-execution/utils/graphql-extract-top-level-fields.util';
const WORKSPACE_RESOLVERS = new Set([
'findManyCompanies',
@@ -20,7 +21,10 @@ describe('classifyTopLevelFields', () => {
`;
expect(
- classifyTopLevelFields(parse(query), undefined, WORKSPACE_RESOLVERS),
+ classifyTopLevelFields(
+ graphQLExtractTopLevelFields(parse(query), undefined),
+ WORKSPACE_RESOLVERS,
+ ),
).toEqual({
hasIntrospectionFields: true,
hasWorkspaceFields: false,
@@ -37,7 +41,10 @@ describe('classifyTopLevelFields', () => {
`;
expect(
- classifyTopLevelFields(parse(query), undefined, WORKSPACE_RESOLVERS),
+ classifyTopLevelFields(
+ graphQLExtractTopLevelFields(parse(query), undefined),
+ WORKSPACE_RESOLVERS,
+ ),
).toEqual({
hasIntrospectionFields: false,
hasWorkspaceFields: true,
@@ -54,7 +61,10 @@ describe('classifyTopLevelFields', () => {
`;
expect(
- classifyTopLevelFields(parse(query), undefined, WORKSPACE_RESOLVERS),
+ classifyTopLevelFields(
+ graphQLExtractTopLevelFields(parse(query), undefined),
+ WORKSPACE_RESOLVERS,
+ ),
).toEqual({
hasIntrospectionFields: false,
hasWorkspaceFields: false,
@@ -71,7 +81,10 @@ describe('classifyTopLevelFields', () => {
`;
expect(
- classifyTopLevelFields(parse(query), undefined, WORKSPACE_RESOLVERS),
+ classifyTopLevelFields(
+ graphQLExtractTopLevelFields(parse(query), undefined),
+ WORKSPACE_RESOLVERS,
+ ),
).toEqual({
hasIntrospectionFields: true,
hasWorkspaceFields: true,
@@ -88,7 +101,10 @@ describe('classifyTopLevelFields', () => {
`;
expect(
- classifyTopLevelFields(parse(query), undefined, WORKSPACE_RESOLVERS),
+ classifyTopLevelFields(
+ graphQLExtractTopLevelFields(parse(query), undefined),
+ WORKSPACE_RESOLVERS,
+ ),
).toEqual({
hasIntrospectionFields: false,
hasWorkspaceFields: true,
@@ -104,7 +120,10 @@ describe('classifyTopLevelFields', () => {
`;
expect(
- classifyTopLevelFields(parse(query), undefined, WORKSPACE_RESOLVERS),
+ classifyTopLevelFields(
+ graphQLExtractTopLevelFields(parse(query), undefined),
+ WORKSPACE_RESOLVERS,
+ ),
).toEqual({
hasIntrospectionFields: false,
hasWorkspaceFields: false,
@@ -124,7 +143,10 @@ describe('classifyTopLevelFields', () => {
`;
expect(
- classifyTopLevelFields(parse(query), undefined, WORKSPACE_RESOLVERS),
+ classifyTopLevelFields(
+ graphQLExtractTopLevelFields(parse(query), undefined),
+ WORKSPACE_RESOLVERS,
+ ),
).toEqual({
hasIntrospectionFields: true,
hasWorkspaceFields: true,
@@ -144,8 +166,7 @@ describe('classifyTopLevelFields', () => {
expect(
classifyTopLevelFields(
- parse(query),
- 'IntrospectionQuery',
+ graphQLExtractTopLevelFields(parse(query), 'IntrospectionQuery'),
WORKSPACE_RESOLVERS,
),
).toEqual({
@@ -156,8 +177,7 @@ describe('classifyTopLevelFields', () => {
expect(
classifyTopLevelFields(
- parse(query),
- 'WorkspaceQuery',
+ graphQLExtractTopLevelFields(parse(query), 'WorkspaceQuery'),
WORKSPACE_RESOLVERS,
),
).toEqual({
diff --git a/packages/twenty-server/src/engine/api/graphql/direct-execution/utils/classify-top-level-fields.util.ts b/packages/twenty-server/src/engine/api/graphql/direct-execution/utils/classify-top-level-fields.util.ts
index c9323285922..878b13a924a 100644
--- a/packages/twenty-server/src/engine/api/graphql/direct-execution/utils/classify-top-level-fields.util.ts
+++ b/packages/twenty-server/src/engine/api/graphql/direct-execution/utils/classify-top-level-fields.util.ts
@@ -1,6 +1,4 @@
-import { type DocumentNode } from 'graphql';
-
-import { graphQLExtractTopLevelFields } from 'src/engine/api/graphql/direct-execution/utils/graphql-extract-top-level-fields.util';
+import { type FieldNode } from 'graphql';
const INTROSPECTION_FIELD_NAMES = new Set(['__schema', '__type']);
@@ -11,12 +9,9 @@ type TopLevelFieldsClassification = {
};
export const classifyTopLevelFields = (
- document: DocumentNode,
- operationName: string | undefined,
+ topLevelFields: FieldNode[],
workspaceResolverNames: Set<string>,
): TopLevelFieldsClassification => {
- const topLevelFields = graphQLExtractTopLevelFields(document, operationName);
-
let hasIntrospectionFields = false;
let hasWorkspaceFields = false;
let hasCoreFields = false;
diff --git a/packages/twenty-server/src/engine/api/graphql/utils/__tests__/capture-executed-root-resolvers.util.spec.ts b/packages/twenty-server/src/engine/api/graphql/utils/__tests__/capture-executed-root-resolvers.util.spec.ts
new file mode 100644
index 00000000000..1ec52717353
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/utils/__tests__/capture-executed-root-resolvers.util.spec.ts
@@ -0,0 +1,56 @@
+import { type Request } from 'express';
+import { parse } from 'graphql';
+
+import { captureExecutedRootResolvers } from 'src/engine/api/graphql/utils/capture-executed-root-resolvers.util';
+import { extractTopLevelFieldsSafely } from 'src/engine/api/graphql/utils/extract-top-level-fields-safely.util';
+
+describe('captureExecutedRootResolvers', () => {
+ const capture = (
+ query: string,
+ operationName?: string,
+ ): string[] | undefined => {
+ const request = {} as Request;
+
+ captureExecutedRootResolvers({
+ request,
+ topLevelFields: extractTopLevelFieldsSafely(parse(query), operationName),
+ });
+
+ return request.executedRootResolvers;
+ };
+
+ it('should record the executed root resolvers', () => {
+ expect(capture('mutation { createOneCompany { id } }')).toEqual([
+ 'createOneCompany',
+ ]);
+ });
+
+ it('should skip introspection fields', () => {
+ expect(
+ capture('query { __typename __schema { queryType { name } } }'),
+ ).toEqual([]);
+ });
+
+ it('should not overwrite what an earlier pipeline already captured', () => {
+ const request = { executedRootResolvers: ['companies'] } as Request;
+
+ captureExecutedRootResolvers({
+ request,
+ topLevelFields: extractTopLevelFieldsSafely(
+ parse('mutation { deleteManyPeople { id } }'),
+ undefined,
+ ),
+ });
+
+ expect(request.executedRootResolvers).toEqual(['companies']);
+ });
+
+ it('should tolerate a missing request', () => {
+ expect(() =>
+ captureExecutedRootResolvers({
+ request: undefined,
+ topLevelFields: [],
+ }),
+ ).not.toThrow();
+ });
+});
diff --git a/packages/twenty-server/src/engine/api/graphql/utils/__tests__/extract-top-level-fields-safely.util.spec.ts b/packages/twenty-server/src/engine/api/graphql/utils/__tests__/extract-top-level-fields-safely.util.spec.ts
new file mode 100644
index 00000000000..bcc08cf9676
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/utils/__tests__/extract-top-level-fields-safely.util.spec.ts
@@ -0,0 +1,22 @@
+import { parse } from 'graphql';
+
+import { extractTopLevelFieldsSafely } from 'src/engine/api/graphql/utils/extract-top-level-fields-safely.util';
+
+describe('extractTopLevelFieldsSafely', () => {
+ it('should return no field instead of throwing when the document is ambiguous', () => {
+ const query = `
+ query ReadPeople {
+ findManyPeople {
+ id
+ }
+ }
+ mutation WipePeople {
+ deleteManyPeople {
+ id
+ }
+ }
+ `;
+
+ expect(extractTopLevelFieldsSafely(parse(query), undefined)).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/engine/api/graphql/utils/capture-executed-root-resolvers.util.ts b/packages/twenty-server/src/engine/api/graphql/utils/capture-executed-root-resolvers.util.ts
new file mode 100644
index 00000000000..c6b091ed144
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/utils/capture-executed-root-resolvers.util.ts
@@ -0,0 +1,19 @@
+import { type Request } from 'express';
+import { type FieldNode } from 'graphql';
+import { isDefined } from 'twenty-shared/utils';
+
+export const captureExecutedRootResolvers = ({
+ request,
+ topLevelFields,
+}: {
+ request: Request | undefined;
+ topLevelFields: FieldNode[];
+}): void => {
+ if (!isDefined(request) || isDefined(request.executedRootResolvers)) {
+ return;
+ }
+
+ request.executedRootResolvers = topLevelFields
+ .map((field) => field.name.value)
+ .filter((name) => !name.startsWith('__'));
+};
diff --git a/packages/twenty-server/src/engine/api/graphql/utils/extract-top-level-fields-safely.util.ts b/packages/twenty-server/src/engine/api/graphql/utils/extract-top-level-fields-safely.util.ts
new file mode 100644
index 00000000000..615ee31cbba
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/graphql/utils/extract-top-level-fields-safely.util.ts
@@ -0,0 +1,14 @@
+import { type DocumentNode, type FieldNode } from 'graphql';
+
+import { graphQLExtractTopLevelFields } from 'src/engine/api/graphql/direct-execution/utils/graphql-extract-top-level-fields.util';
+
+export const extractTopLevelFieldsSafely = (
+ document: DocumentNode,
+ operationName: string | undefined,
+): FieldNode[] => {
+ try {
+ return graphQLExtractTopLevelFields(document, operationName);
+ } catch {
+ return [];
+ }
+};
diff --git a/packages/twenty-server/src/engine/core-modules/graphql/hooks/use-validate-graphql-query-complexity.hook.ts b/packages/twenty-server/src/engine/core-modules/graphql/hooks/use-validate-graphql-query-complexity.hook.ts
index edf4648ea8f..fb00946216c 100644
--- a/packages/twenty-server/src/engine/core-modules/graphql/hooks/use-validate-graphql-query-complexity.hook.ts
+++ b/packages/twenty-server/src/engine/core-modules/graphql/hooks/use-validate-graphql-query-complexity.hook.ts
@@ -6,9 +6,13 @@ import {
type SelectionNode,
Kind,
} from 'graphql';
+import { isNonEmptyString } from '@sniptt/guards';
+import { type Request } from 'express';
import { type Plugin } from 'graphql-yoga';
import { isDefined } from 'twenty-shared/utils';
+import { captureExecutedRootResolvers } from 'src/engine/api/graphql/utils/capture-executed-root-resolvers.util';
+import { extractTopLevelFieldsSafely } from 'src/engine/api/graphql/utils/extract-top-level-fields-safely.util';
import { UserInputError } from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
type FragmentMetadata = {
@@ -35,7 +39,7 @@ export const useValidateGraphqlQueryComplexity = ({
maximumAllowedNestedFields?: number;
checkDuplicateRootResolvers?: boolean;
}): Plugin => ({
- onParse: () => {
+ onParse: ({ context }) => {
return ({ result }) => {
if (!result || !('kind' in result) || result.kind !== Kind.DOCUMENT) {
return;
@@ -44,6 +48,14 @@ export const useValidateGraphqlQueryComplexity = ({
const document = result as DocumentNode;
const fragmentMap = buildFragmentMap(document);
+ captureExecutedRootResolvers({
+ request: extractRequest(context),
+ topLevelFields: extractTopLevelFieldsSafely(
+ document,
+ extractOperationName(context),
+ ),
+ });
+
const analysis = analyzeDocument(
document,
fragmentMap,
@@ -86,6 +98,28 @@ export const useValidateGraphqlQueryComplexity = ({
},
});
+const extractRequest = (context: unknown): Request | undefined =>
+ (context as { req?: Request } | undefined)?.req;
+
+const extractOperationName = (context: unknown): string | undefined => {
+ const typedContext = context as
+ | {
+ params?: { operationName?: unknown };
+ req?: { body?: { operationName?: unknown } };
+ }
+ | undefined;
+
+ const fromParams = typedContext?.params?.operationName;
+
+ if (isNonEmptyString(fromParams)) {
+ return fromParams;
+ }
+
+ const fromBody = typedContext?.req?.body?.operationName;
+
+ return isNonEmptyString(fromBody) ? fromBody : undefined;
+};
+
const buildFragmentMap = (
document: DocumentNode,
): Map<string, FragmentDefinitionNode> => {
diff --git a/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts b/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts
index f32d0e64caa..f1159fa7bc1 100644
--- a/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts
+++ b/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts
@@ -1174,6 +1174,16 @@ export class ConfigVariables {
@IsOptional()
LOGGER_IS_BUFFER_ENABLED = true;
+ @ConfigVariablesMetadata({
+ group: ConfigVariablesGroup.LOGGING,
+ description:
+ 'Log one line per API request with the actor, the endpoint and the trace ids',
+ type: ConfigVariableType.BOOLEAN,
+ isEnvOnly: true,
+ })
+ @IsOptional()
+ API_ACCESS_LOG_ENABLED = false;
+
@ConfigVariablesMetadata({
group: ConfigVariablesGroup.LOGGING,
description: 'Driver used for handling exceptions (Console or Sentry)',
diff --git a/packages/twenty-server/src/engine/middlewares/api-access-log.middleware.ts b/packages/twenty-server/src/engine/middlewares/api-access-log.middleware.ts
new file mode 100644
index 00000000000..192f61ca15c
--- /dev/null
+++ b/packages/twenty-server/src/engine/middlewares/api-access-log.middleware.ts
@@ -0,0 +1,54 @@
+import { Injectable, Logger, type NestMiddleware } from '@nestjs/common';
+
+import { type NextFunction, type Request, type Response } from 'express';
+
+import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
+import { buildApiAccessLogLine } from 'src/engine/middlewares/utils/build-api-access-log-line.util';
+import { computeRequestTraceContext } from 'src/engine/utils/compute-request-trace-context.util';
+
+@Injectable()
+export class ApiAccessLogMiddleware implements NestMiddleware {
+ private readonly logger = new Logger(ApiAccessLogMiddleware.name);
+
+ constructor(private readonly twentyConfigService: TwentyConfigService) {}
+
+ use(request: Request, response: Response, next: NextFunction) {
+ if (!this.twentyConfigService.get('API_ACCESS_LOG_ENABLED')) {
+ next();
+
+ return;
+ }
+
+ const startedAtMs = Date.now();
+ const traceContext = computeRequestTraceContext();
+
+ let logged = false;
+ const log = () => {
+ if (logged) {
+ return;
+ }
+
+ logged = true;
+
+ try {
+ this.logger.log(
+ buildApiAccessLogLine({
+ request,
+ response,
+ durationMs: Date.now() - startedAtMs,
+ traceContext,
+ }),
+ );
+ } catch (error) {
+ this.logger.warn(
+ `Failed to build the access log line: ${error instanceof Error ? error.message : String(error)}`,
+ );
+ }
+ };
+
+ response.once('finish', log);
+ response.once('close', log);
+
+ next();
+ }
+}
diff --git a/packages/twenty-server/src/engine/middlewares/middleware.module.ts b/packages/twenty-server/src/engine/middlewares/middleware.module.ts
index 06236d069ea..e9e95dbf8ff 100644
--- a/packages/twenty-server/src/engine/middlewares/middleware.module.ts
+++ b/packages/twenty-server/src/engine/middlewares/middleware.module.ts
@@ -3,6 +3,7 @@ import { Module } from '@nestjs/common';
import { TokenModule } from 'src/engine/core-modules/auth/token/token.module';
import { JwtModule } from 'src/engine/core-modules/jwt/jwt.module';
import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
+import { ApiAccessLogMiddleware } from 'src/engine/middlewares/api-access-log.middleware';
import { CookieSessionCsrfMiddleware } from 'src/engine/middlewares/cookie-session-csrf.middleware';
import { MiddlewareService } from 'src/engine/middlewares/middleware.service';
import { UserSessionModule } from 'src/engine/core-modules/user-session/user-session.module';
@@ -16,7 +17,15 @@ import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/
JwtModule,
UserSessionModule,
],
- providers: [MiddlewareService, CookieSessionCsrfMiddleware],
- exports: [MiddlewareService, CookieSessionCsrfMiddleware],
+ providers: [
+ MiddlewareService,
+ CookieSessionCsrfMiddleware,
+ ApiAccessLogMiddleware,
+ ],
+ exports: [
+ MiddlewareService,
+ CookieSessionCsrfMiddleware,
+ ApiAccessLogMiddleware,
+ ],
})
export class MiddlewareModule {}
diff --git a/packages/twenty-server/src/engine/middlewares/utils/__tests__/build-api-access-log-line.util.spec.ts b/packages/twenty-server/src/engine/middlewares/utils/__tests__/build-api-access-log-line.util.spec.ts
new file mode 100644
index 00000000000..6ab4c3dbf75
--- /dev/null
+++ b/packages/twenty-server/src/engine/middlewares/utils/__tests__/build-api-access-log-line.util.spec.ts
@@ -0,0 +1,240 @@
+import { type Request, type Response } from 'express';
+
+import { buildApiAccessLogLine } from 'src/engine/middlewares/utils/build-api-access-log-line.util';
+import { type RequestTraceContext } from 'src/engine/utils/compute-request-trace-context.util';
+
+const parseLogfmtKeys = (line: string): string[] => {
+ const keys: string[] = [];
+ let index = 0;
+
+ while (index < line.length) {
+ const equalsIndex = line.indexOf('=', index);
+
+ if (equalsIndex === -1) {
+ break;
+ }
+
+ keys.push(line.slice(index, equalsIndex));
+ index = equalsIndex + 1;
+
+ if (line[index] === '"') {
+ index += 1;
+ while (index < line.length && line[index] !== '"') {
+ index += line[index] === '\\' ? 2 : 1;
+ }
+ index += 1;
+ } else {
+ const spaceIndex = line.indexOf(' ', index);
+
+ index = spaceIndex === -1 ? line.length : spaceIndex;
+ }
+
+ index += 1;
+ }
+
+ return keys;
+};
+
+describe('buildApiAccessLogLine', () => {
+ const build = ({
+ request = {},
+ statusCode = 200,
+ writableEnded = true,
+ durationMs = 12,
+ traceContext,
+ }: {
+ request?: Partial<Request>;
+ statusCode?: number;
+ writableEnded?: boolean;
+ durationMs?: number;
+ traceContext?: RequestTraceContext;
+ } = {}): string =>
+ buildApiAccessLogLine({
+ request: {
+ method: 'POST',
+ originalUrl: '/rest/people/ba91bdfb?depth=1',
+ headers: {},
+ ...request,
+ } as unknown as Request,
+ response: { statusCode, writableEnded } as unknown as Response,
+ durationMs,
+ traceContext,
+ });
+
+ it('should log the path without its query string', () => {
+ const line = build();
+
+ expect(line).toContain('method=POST');
+ expect(line).toContain('url_path=/rest/people/ba91bdfb');
+ expect(line).not.toContain('depth=1');
+ expect(line).toContain('status=200');
+ expect(line).toContain('duration_ms=12');
+ });
+
+ it('should not claim a status for a request the client aborted', () => {
+ const line = build({ writableEnded: false });
+
+ expect(line).toContain('aborted=true');
+ expect(line).not.toContain('status=');
+ expect(line).toContain('duration_ms=12');
+ });
+
+ it('should not mark a completed response as aborted', () => {
+ const line = build();
+
+ expect(line).toContain('status=200');
+ expect(line).not.toContain('aborted=');
+ });
+
+ it('should log the user as actor', () => {
+ const line = build({
+ request: {
+ user: { id: 'user-id' },
+ workspaceId: 'workspace-id',
+ authProvider: 'password',
+ } as unknown as Partial<Request>,
+ });
+
+ expect(line).toContain('actor=user');
+ expect(line).toContain('actor_id=user-id');
+ expect(line).toContain('workspace_id=workspace-id');
+ expect(line).toContain('auth_provider=password');
+ });
+
+ it('should log the impersonator next to the impersonated actor', () => {
+ const line = build({
+ request: {
+ user: { id: 'impersonated-user-id' },
+ authProvider: 'impersonation',
+ impersonationContext: {
+ impersonatorUserWorkspaceId: 'impersonator-user-workspace-id',
+ impersonatedUserWorkspaceId: 'impersonated-user-workspace-id',
+ },
+ } as unknown as Partial<Request>,
+ });
+
+ expect(line).toContain('actor_id=impersonated-user-id');
+ expect(line).toContain(
+ 'impersonator_user_workspace_id=impersonator-user-workspace-id',
+ );
+ expect(line).toContain('auth_provider=impersonation');
+ });
+
+ it('should log anonymous when nothing authenticated the request', () => {
+ const line = build();
+
+ expect(line).toContain('actor=anonymous');
+ expect(line).not.toContain('actor_id=');
+ });
+
+ it('should log the resolvers captured by the graphql pipelines', () => {
+ const line = build({
+ request: {
+ originalUrl: '/graphql',
+ executedRootResolvers: ['createOneCompany', 'deleteManyPeople'],
+ },
+ });
+
+ expect(line).toContain('url_path=/graphql');
+ expect(line).toContain('resolvers=createOneCompany,deleteManyPeople');
+ });
+
+ it('should omit resolvers for a non graphql request', () => {
+ expect(build()).not.toContain('resolvers=');
+ });
+
+ it('should truncate a long resolver list with a remainder count', () => {
+ const line = build({
+ request: {
+ originalUrl: '/graphql',
+ executedRootResolvers: Array.from(
+ { length: 40 },
+ (_unused, index) => `findManyVeryLongObjectName${index}`,
+ ),
+ },
+ });
+
+ expect(line).toMatch(/resolvers=\S*,\+\d+/);
+ });
+
+ it('should log the request id forwarded by the ingress', () => {
+ expect(
+ build({ request: { headers: { 'x-request-id': 'req-abc' } } }),
+ ).toContain('request_id=req-abc');
+ });
+
+ it('should drop an over long request id', () => {
+ const line = build({
+ request: { headers: { 'x-request-id': 'a'.repeat(129) } },
+ });
+
+ expect(line).not.toContain('request_id=');
+ });
+
+ it('should keep a request id at the length limit', () => {
+ const requestId = 'a'.repeat(128);
+
+ expect(
+ build({ request: { headers: { 'x-request-id': requestId } } }),
+ ).toContain(`request_id=${requestId}`);
+ });
+
+ it('should drop a request id that is not id shaped', () => {
+ expect(
+ build({ request: { headers: { 'x-request-id': 'not an id' } } }),
+ ).not.toContain('request_id=');
+ expect(
+ build({
+ request: { headers: { 'x-request-id': 'x\\" actor_id=victim' } },
+ }),
+ ).not.toContain('request_id=');
+ });
+
+ it('should log the trace ids when a span is active', () => {
+ const line = build({
+ traceContext: {
+ traceId: 'trace-abc',
+ spanId: 'span-abc',
+ sampled: true,
+ },
+ });
+
+ expect(line).toContain('trace_id=trace-abc');
+ expect(line).toContain('span_id=span-abc');
+ expect(line).toContain('trace_sampled=true');
+ });
+
+ it('should log an unsampled trace as such', () => {
+ expect(
+ build({
+ traceContext: {
+ traceId: 'trace-abc',
+ spanId: 'span-abc',
+ sampled: false,
+ },
+ }),
+ ).toContain('trace_sampled=false');
+ });
+
+ it('should omit the trace ids when no span is active', () => {
+ const line = build();
+
+ expect(line).not.toContain('trace_id=');
+ expect(line).not.toContain('span_id=');
+ });
+
+ it('should escape a backslash so a crafted value cannot inject fields', () => {
+ const line = build({
+ request: { originalUrl: '/rest/x\\" actor_id=victim x="' },
+ });
+
+ expect(parseLogfmtKeys(line)).not.toContain('actor_id');
+ expect(parseLogfmtKeys(line)).toContain('url_path');
+ });
+
+ it('should quote a value ending in a backslash', () => {
+ expect(build({ request: { originalUrl: '/rest/abc\\' } })).toContain(
+ 'url_path="/rest/abc\\\\"',
+ );
+ });
+});
diff --git a/packages/twenty-server/src/engine/middlewares/utils/build-api-access-log-line.util.ts b/packages/twenty-server/src/engine/middlewares/utils/build-api-access-log-line.util.ts
new file mode 100644
index 00000000000..f5437709730
--- /dev/null
+++ b/packages/twenty-server/src/engine/middlewares/utils/build-api-access-log-line.util.ts
@@ -0,0 +1,101 @@
+import { isNonEmptyString } from '@sniptt/guards';
+import { type Request, type Response } from 'express';
+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
+
+import { computeRequestActor } from 'src/engine/utils/compute-request-actor.util';
+import { type RequestTraceContext } from 'src/engine/utils/compute-request-trace-context.util';
+
+const MAX_LOGGED_RESOLVERS_LENGTH = 512;
+const MAX_LOGGED_REQUEST_ID_LENGTH = 128;
+const REQUEST_ID_PATTERN = /^[A-Za-z0-9_.:-]+$/;
+
+export const buildApiAccessLogLine = ({
+ request,
+ response,
+ durationMs,
+ traceContext,
+}: {
+ request: Request;
+ response: Response;
+ durationMs: number;
+ traceContext: RequestTraceContext | undefined;
+}): string => {
+ const [urlPath] = (request.originalUrl ?? '').split('?');
+ const completed = response.writableEnded;
+
+ return toLogfmt({
+ method: request.method,
+ url_path: urlPath,
+ resolvers: formatResolvers(request.executedRootResolvers),
+ status: completed ? response.statusCode : undefined,
+ aborted: completed ? undefined : true,
+ duration_ms: durationMs,
+ ...formatActor(request),
+ impersonator_user_workspace_id:
+ request.impersonationContext?.impersonatorUserWorkspaceId,
+ workspace_id: request.workspaceId,
+ auth_provider: request.authProvider ?? undefined,
+ token_type: request.tokenType,
+ request_id: formatRequestId(request.headers?.['x-request-id']),
+ trace_id: traceContext?.traceId,
+ span_id: traceContext?.spanId,
+ trace_sampled: traceContext?.sampled,
+ });
+};
+
+const formatActor = (request: Request): Record<string, string | undefined> => {
+ const actor = computeRequestActor(request);
+
+ return isDefined(actor)
+ ? { actor: actor.kind, actor_id: actor.id }
+ : { actor: 'anonymous' };
+};
+
+const formatRequestId = (value: string | string[] | undefined) => {
+ const requestId = Array.isArray(value) ? value[0] : value;
+
+ return isNonEmptyString(requestId) &&
+ requestId.length <= MAX_LOGGED_REQUEST_ID_LENGTH &&
+ REQUEST_ID_PATTERN.test(requestId)
+ ? requestId
+ : undefined;
+};
+
+const formatResolvers = (resolvers: string[] | undefined) => {
+ if (!isNonEmptyArray(resolvers)) {
+ return undefined;
+ }
+
+ const joined = resolvers.join(',');
+
+ if (joined.length <= MAX_LOGGED_RESOLVERS_LENGTH) {
+ return joined;
+ }
+
+ const kept: string[] = [];
+ let length = 0;
+
+ for (const name of resolvers) {
+ if (length + name.length + 1 > MAX_LOGGED_RESOLVERS_LENGTH) {
+ break;
+ }
+
+ kept.push(name);
+ length += name.length + 1;
+ }
+
+ return `${kept.join(',')},+${resolvers.length - kept.length}`;
+};
+
+const toLogfmt = (
+ fields: Record<string, string | number | boolean | undefined>,
+): string =>
+ Object.entries(fields)
+ .filter(([, value]) => isDefined(value))
+ .map(([key, value]) => `${key}=${quote(String(value))}`)
+ .join(' ');
+
+const quote = (value: string): string =>
+ isNonEmptyString(value) && !/[\s"=\\]/.test(value)
+ ? value
+ : `"${value.replace(/[\\"]/g, (character) => `\\${character}`)}"`;
diff --git a/packages/twenty-server/src/engine/utils/__tests__/compute-request-actor.util.spec.ts b/packages/twenty-server/src/engine/utils/__tests__/compute-request-actor.util.spec.ts
new file mode 100644
index 00000000000..b2e70406eb5
--- /dev/null
+++ b/packages/twenty-server/src/engine/utils/__tests__/compute-request-actor.util.spec.ts
@@ -0,0 +1,34 @@
+import { computeRequestActor } from 'src/engine/utils/compute-request-actor.util';
+
+describe('computeRequestActor', () => {
+ it('should prefer the api key over the application and the user', () => {
+ expect(
+ computeRequestActor({
+ apiKey: { id: 'api-key-id' },
+ application: { id: 'application-id' },
+ user: { id: 'user-id' },
+ }),
+ ).toEqual({ kind: 'apiKey', id: 'api-key-id' });
+ });
+
+ it('should prefer the application over the user', () => {
+ expect(
+ computeRequestActor({
+ application: { id: 'application-id' },
+ user: { id: 'user-id' },
+ }),
+ ).toEqual({ kind: 'application', id: 'application-id' });
+ });
+
+ it('should fall back to the user', () => {
+ expect(
+ computeRequestActor({
+ user: { id: 'user-id' },
+ }),
+ ).toEqual({ kind: 'user', id: 'user-id' });
+ });
+
+ it('should return undefined when nothing authenticated the request', () => {
+ expect(computeRequestActor({})).toBeUndefined();
+ });
+});
diff --git a/packages/twenty-server/src/engine/utils/compute-request-actor.util.ts b/packages/twenty-server/src/engine/utils/compute-request-actor.util.ts
new file mode 100644
index 00000000000..b4f620d4b4a
--- /dev/null
+++ b/packages/twenty-server/src/engine/utils/compute-request-actor.util.ts
@@ -0,0 +1,30 @@
+import { isDefined } from 'twenty-shared/utils';
+
+export type RequestActor = {
+ kind: 'apiKey' | 'application' | 'user';
+ id: string;
+};
+
+type RequestActorCandidates = {
+ apiKey?: { id: string } | null;
+ application?: { id: string } | null;
+ user?: { id: string } | null;
+};
+
+export const computeRequestActor = (
+ data: RequestActorCandidates,
+): RequestActor | undefined => {
+ if (isDefined(data.apiKey)) {
+ return { kind: 'apiKey', id: data.apiKey.id };
+ }
+
+ if (isDefined(data.application)) {
+ return { kind: 'application', id: data.application.id };
+ }
+
+ if (isDefined(data.user)) {
+ return { kind: 'user', id: data.user.id };
+ }
+
+ return undefined;
+};
diff --git a/packages/twenty-server/src/engine/utils/compute-request-trace-context.util.ts b/packages/twenty-server/src/engine/utils/compute-request-trace-context.util.ts
new file mode 100644
index 00000000000..6f2ea4a59c0
--- /dev/null
+++ b/packages/twenty-server/src/engine/utils/compute-request-trace-context.util.ts
@@ -0,0 +1,29 @@
+import * as Sentry from '@sentry/node';
+import { isDefined } from 'twenty-shared/utils';
+
+export type RequestTraceContext = {
+ traceId: string;
+ spanId: string;
+ sampled: boolean;
+};
+
+const INVALID_TRACE_ID = '0'.repeat(32);
+const INVALID_SPAN_ID = '0'.repeat(16);
+
+export const computeRequestTraceContext = ():
+ | RequestTraceContext
+ | undefined => {
+ const span = Sentry.getActiveSpan();
+
+ if (!isDefined(span)) {
+ return undefined;
+ }
+
+ const { traceId, spanId, traceFlags } = span.spanContext();
+
+ if (traceId === INVALID_TRACE_ID || spanId === INVALID_SPAN_ID) {
+ return undefined;
+ }
+
+ return { traceId, spanId, sampled: (traceFlags & 1) === 1 };
+};
diff --git a/packages/twenty-server/test/integration/access-log/api-access-log.integration-spec.ts b/packages/twenty-server/test/integration/access-log/api-access-log.integration-spec.ts
new file mode 100644
index 00000000000..0538827d26e
--- /dev/null
+++ b/packages/twenty-server/test/integration/access-log/api-access-log.integration-spec.ts
@@ -0,0 +1,182 @@
+import { randomUUID } from 'node:crypto';
+
+import { ConsoleLogger } from '@nestjs/common';
+import gql from 'graphql-tag';
+import request from 'supertest';
+
+import { type TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+import { USER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/core/utils/seed-users.util';
+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { makeRestAPIRequest } from 'test/integration/rest/utils/make-rest-api-request.util';
+import { expectEventually } from 'test/integration/utils/expect-eventually.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+
+/* global APP_PORT */
+
+const FIND_MANY_PEOPLE = gql`
+ query FindManyPeople {
+ people(first: 1) {
+ edges {
+ node {
+ id
+ }
+ }
+ }
+ }
+`;
+
+const loggedMessages: string[] = [];
+
+class RecordingLogger extends ConsoleLogger {
+ log(message: unknown, context?: string) {
+ loggedMessages.push(String(message));
+ super.log(message, context);
+ }
+}
+
+const parseLogfmt = (line: string): Record<string, string> =>
+ Object.fromEntries(
+ [...line.matchAll(/([a-z_]+)=("(?:[^"\\]|\\.)*"|\S+)/g)].map(
+ ([, key, value]) => [
+ key,
+ value.startsWith('"') ? JSON.parse(value) : value,
+ ],
+ ),
+ );
+
+describe('API access log', () => {
+ const twentyConfigService = getAppProviderByClassName<TwentyConfigService>(
+ 'TwentyConfigService',
+ );
+ const readConfig = twentyConfigService.get.bind(twentyConfigService);
+
+ let isAccessLogEnabled = true;
+
+ const accessLogLinesOf = (requestId: string) =>
+ loggedMessages
+ .filter((message) => message.includes(`request_id=${requestId}`))
+ .map(parseLogfmt);
+
+ const waitForAccessLogLine = async (requestId: string) => {
+ await expectEventually(() => {
+ expect(accessLogLinesOf(requestId)).toHaveLength(1);
+ });
+
+ return accessLogLinesOf(requestId)[0];
+ };
+
+ const findManyPeople = (requestId: string) =>
+ makeGraphqlAPIRequest({ query: FIND_MANY_PEOPLE }).set(
+ 'x-request-id',
+ requestId,
+ );
+
+ // A request that is not logged has no event to wait for, so a logged request
+ // issued after it is the synchronisation point.
+ const expectNothingLoggedFor = async (requestId: string) => {
+ const loggedRequestId = randomUUID();
+
+ isAccessLogEnabled = true;
+ await findManyPeople(loggedRequestId);
+ await waitForAccessLogLine(loggedRequestId);
+
+ expect(accessLogLinesOf(requestId)).toHaveLength(0);
+ };
+
+ beforeAll(() => {
+ jest
+ .spyOn(twentyConfigService, 'get')
+ .mockImplementation((key) =>
+ key === 'API_ACCESS_LOG_ENABLED' ? isAccessLogEnabled : readConfig(key),
+ );
+
+ global.app.useLogger(new RecordingLogger());
+ });
+
+ afterAll(() => {
+ jest.restoreAllMocks();
+ global.app.useLogger(new ConsoleLogger());
+ });
+
+ beforeEach(() => {
+ isAccessLogEnabled = true;
+ loggedMessages.length = 0;
+ });
+
+ it('should log one line attributing a GraphQL request to its user', async () => {
+ const requestId = randomUUID();
+
+ const response = await findManyPeople(requestId);
+
+ expect(response.body.errors).toBeUndefined();
+
+ const line = await waitForAccessLogLine(requestId);
+
+ expect(line).toMatchObject({
+ method: 'POST',
+ url_path: '/graphql',
+ resolvers: 'people',
+ status: '200',
+ actor: 'user',
+ actor_id: USER_DATA_SEED_IDS.JANE,
+ workspace_id: SEED_APPLE_WORKSPACE_ID,
+ auth_provider: 'password',
+ token_type: 'ACCESS',
+ request_id: requestId,
+ });
+ expect(Number(line.duration_ms)).toBeGreaterThanOrEqual(0);
+ });
+
+ it('should log the api key as the actor of a REST request', async () => {
+ const requestId = randomUUID();
+
+ await makeRestAPIRequest({ method: 'get', path: '/people?limit=1' }).set(
+ 'x-request-id',
+ requestId,
+ );
+
+ const line = await waitForAccessLogLine(requestId);
+
+ expect(line).toMatchObject({
+ method: 'GET',
+ url_path: '/rest/people',
+ actor: 'apiKey',
+ workspace_id: SEED_APPLE_WORKSPACE_ID,
+ });
+ expect(line.actor_id).toBeDefined();
+ });
+
+ it('should log an unauthenticated request as anonymous', async () => {
+ const requestId = randomUUID();
+
+ await request(`http://localhost:${APP_PORT}`)
+ .post('/graphql')
+ .set('x-request-id', requestId)
+ .send({ query: '{ __typename }' });
+
+ const line = await waitForAccessLogLine(requestId);
+
+ expect(line.actor).toBe('anonymous');
+ expect(line.actor_id).toBeUndefined();
+ });
+
+ it('should not log the health check', async () => {
+ const requestId = randomUUID();
+
+ await request(`http://localhost:${APP_PORT}`)
+ .get('/healthz')
+ .set('x-request-id', requestId);
+
+ await expectNothingLoggedFor(requestId);
+ });
+
+ it('should not log anything when the config variable is off', async () => {
+ const requestId = randomUUID();
+
+ isAccessLogEnabled = false;
+ await findManyPeople(requestId);
+
+ await expectNothingLoggedFor(requestId);
+ });
+});