The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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);+ });+});