@squiz/optimization-utils 1.0.0

package/src/httpClient/__tests__/httpRequestBuilder.spec.ts

@@ -0,0 +1,75 @@
+import { Container } from 'inversify';
+import { faker } from '@faker-js/faker';
+import {
+  HttpClient,
+  HttpMethod,
+  HttpRequestOptions,
+  HttpResponse,
+} from '../HttpClient';
+import { HttpRequestBuilderFactory } from '../HttpRequestBuilder';
+import { createHttpClientMock } from '../../testing/mock';
+
+describe('HttpRequestBuilder', () => {
+  let httpClient: HttpClient;
+  let httpRequestBuilderFactory: HttpRequestBuilderFactory;
+
+  beforeEach(() => {
+    const container = new Container();
+
+    container.bind(HttpClient).toConstantValue(createHttpClientMock());
+    container.bind(HttpRequestBuilderFactory).to(HttpRequestBuilderFactory);
+
+    httpClient = container.get(HttpClient);
+    httpRequestBuilderFactory = container.get(HttpRequestBuilderFactory);
+  });
+
+  it('should compose all params and call HttpClient from builder', async () => {
+    const expectedResponse = new HttpResponse({
+      statusCode: 200,
+      body: undefined,
+    });
+    const params = {
+      url: faker.internet.url(),
+      method: faker.helpers.arrayElement(Object.values(HttpMethod)),
+      headers: {
+        example: faker.word.words(),
+      },
+      body: {
+        exampleBody: faker.word.words(),
+      },
+      handleHttpErrorStatusCodes: [401, 403, 404],
+    };
+    const bearerToken = faker.word.words();
+    const apiKey = faker.word.words();
+
+    jest
+      .spyOn(httpClient, 'sendRequest')
+      .mockResolvedValueOnce(expectedResponse);
+
+    const response = await httpRequestBuilderFactory
+      .create()
+      .url(params.url)
+      .method(params.method)
+      .body(params.body)
+      .headers(params.headers)
+      .applicationJson()
+      .authorizationByBearer(bearerToken)
+      .authorizationByXApiKey(apiKey)
+      .handleErrorStatusCode(params.handleHttpErrorStatusCodes[0])
+      .handleErrorStatusCode(params.handleHttpErrorStatusCodes[1])
+      .handleNotFound()
+      .sendRequest();
+
+    expect(response).toEqual(expectedResponse);
+    expect(httpClient.sendRequest).toHaveBeenCalledWith({
+      ...params,
+      headers: expect.objectContaining({
+        ...params.headers,
+        Authorization: `Bearer ${bearerToken}`,
+        'x-api-key': apiKey,
+        'Content-Type': 'application/json',
+      }),
+      handleHttpErrorStatusCodes: params.handleHttpErrorStatusCodes,
+    } as HttpRequestOptions);
+  });
+});

package/src/logger/Logger.ts

@@ -0,0 +1,40 @@
+import {
+  createLogger as createWinstonLogger,
+  format,
+  LeveledLogMethod,
+  Logform,
+  LogMethod,
+  transports,
+} from 'winston';
+
+export abstract class Logger {
+  abstract log: LogMethod;
+  abstract error: LeveledLogMethod;
+  abstract warn: LeveledLogMethod;
+  abstract info: LeveledLogMethod;
+  abstract debug: LeveledLogMethod;
+  abstract verbose: LeveledLogMethod;
+}
+
+const lambdaFormat = (): Logform.Format => {
+  return format.printf(({ ...attrs }) => {
+    // https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html#configuration-envvars-runtime
+    return JSON.stringify({
+      type: 'app',
+      env: process.env.ENV,
+      name: process.env.AWS_LAMBDA_FUNCTION_NAME,
+      version: process.env.AWS_LAMBDA_FUNCTION_VERSION,
+      region: process.env.AWS_REGION,
+      trace: process.env._X_AMZN_TRACE_ID,
+      ...attrs,
+    });
+  });
+};
+
+export function createLogger(): Logger {
+  return createWinstonLogger({
+    level: process.env.LOGGING_LEVEL || 'debug',
+    format: format.combine(format.timestamp(), format.splat(), lambdaFormat()),
+    transports: [new transports.Console()],
+  });
+}

package/src/logger/LoggerMessage.ts

@@ -0,0 +1,151 @@
+import { randomUUID } from 'crypto';
+
+type ValueOf = {
+  valueOf(): string;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const normalizeCaller = <T extends abstract new (...args: any) => any>(
+  stringOrClassInstance: string | InstanceType<T>,
+): string =>
+  typeof stringOrClassInstance === 'string'
+    ? stringOrClassInstance
+    : stringOrClassInstance.constructor.name;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function createLogMessage<T extends abstract new (...args: any) => any>(
+  ...metadata: Array<string | InstanceType<T>>
+): (message?: string) => string {
+  const context = randomUUID();
+
+  const formattedMetadata = [...metadata, `Context: ${context}`]
+    .filter((data) => !!data)
+    .map((data) => `[${normalizeCaller(data)}]`)
+    .join('');
+
+  return (message) => `${formattedMetadata} ${message ?? ''}`;
+}
+
+export const TENANT_ID_METADATA = (
+  tenantId: string | ValueOf,
+): {
+  tenantId: string;
+} => ({
+  tenantId: typeof tenantId === 'string' ? tenantId : tenantId.valueOf(),
+});
+
+export const PROCESSABLE_LOG_METADATA = { processable: true } as const;
+
+export type LogMessage = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  message: string | any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+) => [string | any, Record<string, unknown>];
+export type CreateLog = {
+  attachMetadata: (metadata: Record<string, unknown>) => CreateLog;
+  attachEventName: (eventName: string) => CreateLog;
+  attachCorrelationId: (id: string) => CreateLog;
+  attachTenantId: (tenantId: string | ValueOf) => CreateLog;
+  attachExperimentId: (experimentId: string | ValueOf) => CreateLog;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  attachCaller: <T extends abstract new (...args: any) => any>(
+    caller: InstanceType<T> | string,
+  ) => CreateLog;
+  isProcessable: () => CreateLog;
+  getMetadata: () => Record<string, unknown>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  create: <T extends abstract new (...args: any) => any>(
+    caller?: InstanceType<T> | string,
+  ) => LogMessage;
+};
+
+export function createLog(opts?: {
+  message?: string;
+  metadata?: Record<string, string | boolean | unknown>;
+}): CreateLog {
+  opts = {
+    metadata: {
+      context: randomUUID(),
+      ...opts?.metadata,
+    },
+    message: opts?.message,
+  };
+
+  const attachMetadata = (
+    metadata: Record<string, string | boolean | unknown>,
+  ): CreateLog => {
+    return createLog({
+      ...(opts && opts),
+      metadata: {
+        ...opts?.metadata,
+        ...metadata,
+      },
+    });
+  };
+
+  const attachTenantId = (tenantId: string | ValueOf): CreateLog => {
+    return attachMetadata(TENANT_ID_METADATA(tenantId));
+  };
+
+  const attachExperimentId = (experimentId: string | ValueOf): CreateLog => {
+    return attachMetadata({
+      experimentId:
+        typeof experimentId === 'string'
+          ? experimentId
+          : experimentId.valueOf(),
+    });
+  };
+
+  const attachEventName = (eventName: string): CreateLog => {
+    return attachMetadata({
+      eventName,
+    });
+  };
+
+  const attachCorrelationId = (id: string): CreateLog => {
+    return attachMetadata({
+      correlationId: id,
+    });
+  };
+
+  const isProcessable = (): CreateLog => {
+    return attachMetadata(PROCESSABLE_LOG_METADATA);
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const attachCaller = <T extends abstract new (...args: any) => any>(
+    caller: T | string,
+  ): CreateLog => {
+    return attachMetadata({
+      caller: normalizeCaller(caller),
+    });
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const create = <T extends abstract new (...args: any) => any>(
+    caller?: T | string,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ): ((message: string | any) => [string | any, Record<string, unknown>]) => {
+    const metadata = {
+      ...opts?.metadata,
+      ...(caller && {
+        caller: normalizeCaller(caller),
+      }),
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (message: string | any) => [message, metadata];
+  };
+
+  return {
+    attachMetadata,
+    attachTenantId,
+    attachExperimentId,
+    attachEventName,
+    attachCorrelationId,
+    isProcessable,
+    attachCaller,
+    getMetadata: () => opts?.metadata ?? {},
+    create,
+  };
+}

package/src/logger/RemoteLogger.ts

@@ -0,0 +1,32 @@
+import { TenantId } from './../valueObject/TenantId';
+import { injectable } from 'inversify';
+import { z } from 'zod';
+
+export enum RemoteLogLevel {
+  INFO = 'info',
+  WARN = 'warn',
+  ERROR = 'error',
+}
+
+export const REMOTE_LOG_SCHEMA = z.object({
+  tenantId: z.string().transform((v) => new TenantId(v)),
+  message: z.string(),
+  timestamp: z
+    .string()
+    .datetime()
+    .transform((v) => new Date(v))
+    .optional(),
+  level: z.nativeEnum(RemoteLogLevel),
+});
+export type RemoteLog = z.infer<typeof REMOTE_LOG_SCHEMA>;
+
+@injectable()
+export abstract class RemoteLogger {
+  abstract info(log: Omit<RemoteLog, 'level'>): Promise<void>;
+
+  abstract warn(log: Omit<RemoteLog, 'level'>): Promise<void>;
+
+  abstract error(log: Omit<RemoteLog, 'level'>): Promise<void>;
+
+  abstract log(logs: ReadonlyArray<RemoteLog>): Promise<void>;
+}

package/src/logger/SquizRemoteLogger.ts

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+import { RemoteLog, RemoteLogLevel, RemoteLogger } from './RemoteLogger';
+import { TenantId } from './../valueObject/TenantId';
+import { injectable } from 'inversify';
+import { Logger } from './Logger';
+import { HttpRequestBuilderFactory } from './../httpClient/HttpRequestBuilder';
+import { createLogMessage } from './LoggerMessage';
+import { HttpMethod } from './../httpClient/HttpClient';
+
+export type SquizRemoteLoggerServiceConfig = {
+  loggerServiceUrl: URL;
+  createLogsPath: string;
+  apiKey: string;
+  serviceName: string;
+};
+export type SquizRemoteLoggerServiceConfigProvider =
+  () => Promise<SquizRemoteLoggerServiceConfig>;
+
+const CREATE_LOGS_REQUEST_BODY_DTO_SCHEMA = z
+  .object({
+    level: z.enum(['INFO', 'WARNING', 'ERROR']),
+    service: z.string(),
+    timestamp: z.string().datetime(),
+    host: z.string().optional(),
+    userid: z.string().optional(),
+    message: z.string().optional(),
+    tags: z.string().optional(),
+    traceid: z.string().optional(),
+  })
+  .array();
+
+export type CreateLogsRequestBodyDto = z.infer<
+  typeof CREATE_LOGS_REQUEST_BODY_DTO_SCHEMA
+>;
+
+@injectable()
+export class SquizRemoteLogger implements RemoteLogger {
+  constructor(
+    private readonly config: SquizRemoteLoggerServiceConfigProvider,
+    private readonly logger: Logger,
+    private readonly httpRequestBuilderFactory: HttpRequestBuilderFactory,
+  ) {}
+
+  async info(log: Omit<RemoteLog, 'level'>): Promise<void> {
+    await this.callApi(log.tenantId, [
+      await this.mapRemoteToRequestBody({
+        ...log,
+        level: RemoteLogLevel.INFO,
+      }),
+    ]);
+  }
+
+  async warn(log: Omit<RemoteLog, 'level'>): Promise<void> {
+    await this.callApi(log.tenantId, [
+      await this.mapRemoteToRequestBody({
+        ...log,
+        level: RemoteLogLevel.WARN,
+      }),
+    ]);
+  }
+
+  async error(log: Omit<RemoteLog, 'level'>): Promise<void> {
+    await this.callApi(log.tenantId, [
+      await this.mapRemoteToRequestBody({
+        ...log,
+        level: RemoteLogLevel.ERROR,
+      }),
+    ]);
+  }
+
+  async log(logs: ReadonlyArray<RemoteLog>): Promise<void> {
+    const logsGrouped = await logs.reduce(
+      async (acc, log) => {
+        const resolvedAcc = await acc;
+        const tenantLogs = resolvedAcc[log.tenantId.valueOf()];
+        const mappedLog = await this.mapRemoteToRequestBody(log);
+        const mappedLogs: CreateLogsRequestBodyDto = tenantLogs
+          ? [...tenantLogs, mappedLog]
+          : [mappedLog];
+
+        return {
+          ...resolvedAcc,
+          [log.tenantId.valueOf()]: mappedLogs,
+        };
+      },
+      Promise.resolve({}) as Promise<Record<string, CreateLogsRequestBodyDto>>,
+    );
+
+    const entries = Object.entries(logsGrouped);
+    const promises = entries.map(async ([tenantId, logs]) => {
+      await this.callApi(new TenantId(tenantId), logs);
+    });
+
+    await Promise.all(promises);
+  }
+
+  private async mapRemoteToRequestBody({
+    tenantId,
+    ...log
+  }: RemoteLog): Promise<CreateLogsRequestBodyDto[number]> {
+    const config = await this.config();
+    const logLevels = new Map<
+      RemoteLogLevel,
+      CreateLogsRequestBodyDto[number]['level']
+    >([
+      [RemoteLogLevel.INFO, 'INFO'],
+      [RemoteLogLevel.WARN, 'WARNING'],
+      [RemoteLogLevel.ERROR, 'ERROR'],
+    ]);
+
+    return {
+      ...log,
+      timestamp: log.timestamp
+        ? log.timestamp.toISOString()
+        : new Date().toISOString(),
+      level: logLevels.get(
+        log.level,
+      ) as CreateLogsRequestBodyDto[number]['level'],
+      service: config.serviceName,
+    };
+  }
+
+  private async callApi(
+    tenantId: TenantId,
+    logs: CreateLogsRequestBodyDto,
+  ): Promise<void> {
+    if (!logs.length) {
+      return;
+    }
+
+    const logMessage = createLogMessage(
+      this,
+      `tenantId: ${tenantId.valueOf()}`,
+    );
+
+    this.logger.debug(logMessage(`started receiving config`));
+    const config = await this.config();
+
+    this.logger.debug(logMessage(`finished receiving config`));
+
+    const url = new URL(
+      config.createLogsPath + `/${tenantId.valueOf()}`,
+      config.loggerServiceUrl,
+    );
+
+    this.logger.debug(logMessage(`started request to: ${url.toString()}`));
+    await this.httpRequestBuilderFactory
+      .create()
+      .url(url)
+      .method(HttpMethod.POST)
+      .applicationJson()
+      .authorizationByXApiKey(config.apiKey)
+      .body(logs)
+      .sendRequest();
+    this.logger.debug(logMessage(`finished request to: ${url.toString()}`));
+  }
+}

package/src/logger/__tests__/LoggerMessage.spec.ts

@@ -0,0 +1,133 @@
+import { randomUUID } from 'crypto';
+import { createLog, createLogMessage } from '../LoggerMessage';
+import { TenantId } from '../../valueObject/TenantId';
+
+jest.mock('crypto');
+
+describe('createLogMessage', () => {
+  class ExampleClass {}
+
+  const mockUUID = (uuid: string): jest.Mock =>
+    (randomUUID as jest.Mock).mockReturnValueOnce(uuid);
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('should create a log message with the instance of class', () => {
+    mockUUID('some-uuid');
+
+    const logMessage = createLogMessage(new ExampleClass());
+
+    expect(logMessage('example message')).toBe(
+      '[ExampleClass][Context: some-uuid] example message',
+    );
+  });
+
+  it('should create a log message with given metadata', () => {
+    mockUUID('some-uuid');
+
+    const logMessage = createLogMessage(
+      new ExampleClass(),
+      'secondMetadata',
+      'thirdMetadata',
+    );
+
+    expect(logMessage('example message')).toBe(
+      '[ExampleClass][secondMetadata][thirdMetadata][Context: some-uuid] example message',
+    );
+  });
+
+  it('should create a log message without additional metadata', () => {
+    mockUUID('some-uuid');
+
+    const logMessage = createLogMessage();
+
+    expect(logMessage('example message')).toBe(
+      '[Context: some-uuid] example message',
+    );
+  });
+});
+
+describe('createLog', () => {
+  const mockUUID: jest.Mock<
+    ReturnType<typeof randomUUID>,
+    Parameters<typeof randomUUID>
+  > = randomUUID as jest.Mock;
+
+  beforeEach(() => {
+    mockUUID.mockReset();
+  });
+
+  it('should create a log message with attached tenant id as metadata', () => {
+    const logMessage = createLog().attachTenantId(new TenantId('1')).create();
+
+    const [, metadata] = logMessage('test');
+
+    expect(metadata).toEqual({ tenantId: '1' });
+  });
+
+  it('should create a log message with attached processable = true as metadata', () => {
+    const logMessage = createLog().isProcessable().create();
+
+    const [, metadata] = logMessage('test');
+
+    expect(metadata).toEqual({ processable: true });
+  });
+
+  it('should create a log message with given message', () => {
+    const logMessage = createLog().isProcessable().create();
+
+    const [message] = logMessage('test');
+
+    expect(message).toContain('test');
+  });
+
+  it('should create a log message with message and caller', () => {
+    class ExampleClass {}
+
+    const logMessage = createLog().isProcessable().create(new ExampleClass());
+
+    const [message] = logMessage('test');
+
+    expect(message).toContain('test');
+  });
+
+  it('should combine metadata', () => {
+    mockUUID.mockReturnValue('70c1d16a-c15f-462b-844b-c2cd379f425f');
+
+    const logMessage = createLog()
+      .attachTenantId(new TenantId('1'))
+      .isProcessable()
+      .attachMetadata({ some: 'metadata' })
+      .create('SomeCaller');
+
+    const [, metadata] = logMessage('test');
+
+    expect(metadata).toEqual({
+      tenantId: '1',
+      processable: true,
+      some: 'metadata',
+      context: '70c1d16a-c15f-462b-844b-c2cd379f425f',
+      caller: 'SomeCaller',
+    });
+  });
+
+  it('should take the context from the base createLog function', () => {
+    mockUUID
+      .mockReturnValueOnce('70c1d16a-c15f-462b-844b-c2cd379f425f')
+      .mockReturnValue('16ed5709-8e7f-4fcd-a4e4-73dd01a66914');
+
+    const baseLogger = createLog();
+
+    const logMessage = createLog({
+      metadata: baseLogger.getMetadata(),
+    }).create();
+
+    const [, metadata] = logMessage('test');
+
+    expect(metadata).toEqual({
+      context: '70c1d16a-c15f-462b-844b-c2cd379f425f',
+    });
+  });
+});