@squiz/optimization-utils 2.0.0 → 2.0.2

package/src/logger/SquizRemoteLogger.ts

@@ -1,154 +0,0 @@
-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 { HttpMethod } from '../httpClient/HttpClient';
-import { createLog } from './LoggerMessage';
-
-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 = createLog().attachTenantId(tenantId).create(this);
-
-    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

@@ -1,147 +0,0 @@
-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',
-    });
-  });
-
-  it('should attach remote to the log', () => {
-    const logMessage = createLog().create();
-
-    const result = logMessage.remote(
-      'example message',
-      new TenantId('example-tenant'),
-    );
-
-    expect(result).toEqual([
-      'example message',
-      { remote: true, tenantId: 'example-tenant' },
-    ]);
-  });
-});

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

@@ -1,77 +0,0 @@
-import { LogsHandler } from '../LogsHandler';
-import zlib from 'zlib';
-import { CloudWatchLogsEvent } from 'aws-lambda';
-import { faker } from '@faker-js/faker';
-import { CloudWatchLogsLogEvent } from 'aws-lambda/trigger/cloudwatch-logs';
-import { RemoteLog, RemoteLogger, RemoteLogLevel } from '../RemoteLogger';
-import { createLoggerMock, createRemoteLoggerMock } from '../../testing/mock';
-import { TenantId } from '../../valueObject/TenantId';
-
-const createCloudWatchEvent = (
-  logs: Array<Record<string, unknown>>,
-): CloudWatchLogsEvent => {
-  const cloudWatchLogsLogEvents: Array<CloudWatchLogsLogEvent> = logs.map(
-    (l) => {
-      return {
-        id: faker.number.bigInt().toString(),
-        timestamp: faker.date.past().valueOf(),
-        message: JSON.stringify(l),
-      };
-    },
-  );
-  const base64 = Buffer.from(
-    JSON.stringify({ logEvents: cloudWatchLogsLogEvents }),
-  );
-  const zipped = zlib.gzipSync(base64);
-
-  return {
-    awslogs: {
-      data: zipped.toString('base64'),
-    },
-  };
-};
-
-describe('LogsHandler', () => {
-  let logsHandler: LogsHandler;
-  let remoteLogger: RemoteLogger;
-  const remoteLog: Omit<RemoteLog, 'tenantId'> & {
-    tenantId: string;
-  } = {
-    level: faker.helpers.arrayElement(Object.values(RemoteLogLevel)),
-    message: faker.word.words(),
-    tenantId: faker.word.words(),
-    timestamp: faker.date.past(),
-  };
-
-  beforeEach(() => {
-    remoteLogger = createRemoteLoggerMock();
-
-    logsHandler = new LogsHandler(remoteLogger, createLoggerMock());
-  });
-
-  it('should decode a CloudWatchLogsEvent and send to the RemoteLogger', async () => {
-    await logsHandler.handle(createCloudWatchEvent([remoteLog]));
-
-    expect(remoteLogger.log).toHaveBeenCalledWith([
-      {
-        ...remoteLog,
-        tenantId: new TenantId(remoteLog.tenantId),
-      },
-    ]);
-  });
-
-  it('should decode a CloudWatchLogsEvent and send only the RemoteLogs to the RemoteLogger', async () => {
-    const otherLog = {
-      test: faker.word.words(),
-    };
-
-    await logsHandler.handle(createCloudWatchEvent([remoteLog, otherLog]));
-
-    expect(remoteLogger.log).toHaveBeenCalledWith([
-      {
-        ...remoteLog,
-        tenantId: new TenantId(remoteLog.tenantId),
-      },
-    ]);
-  });
-});

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

@@ -1,185 +0,0 @@
-import { faker } from '@faker-js/faker';
-import { createHttpClientMock, createLoggerMock } from '../../testing/mock';
-import { Container } from 'inversify';
-import { HttpRequestBuilderFactory } from '../../httpClient/HttpRequestBuilder';
-import {
-  HttpClient,
-  HttpMethod,
-  HttpRequestOptions,
-  HttpResponse,
-} from '../../httpClient/HttpClient';
-import { Logger } from '../Logger';
-import {
-  CreateLogsRequestBodyDto,
-  SquizRemoteLogger,
-  SquizRemoteLoggerServiceConfigProvider,
-} from '../SquizRemoteLogger';
-import { RemoteLogLevel, RemoteLogger } from '../RemoteLogger';
-import { TenantId } from '../../valueObject/TenantId';
-
-describe('SquizRemoteLogger', () => {
-  let logger: RemoteLogger;
-  let httpClient: HttpClient;
-  const config: Awaited<ReturnType<SquizRemoteLoggerServiceConfigProvider>> = {
-    loggerServiceUrl: new URL(
-      'https://develop-apps-dxp-console.dev.dxp.squiz.cloud',
-    ),
-    createLogsPath: '/__dxp/us/logging',
-    apiKey: 'apiKey',
-    serviceName: 'experiment',
-  };
-  const expectedPayload = (
-    tenantId: string,
-    body: CreateLogsRequestBodyDto,
-  ): HttpRequestOptions => {
-    return {
-      url: new URL(
-        `https://develop-apps-dxp-console.dev.dxp.squiz.cloud/__dxp/us/logging/${tenantId}`,
-      ),
-      method: HttpMethod.POST,
-      body,
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': 'apiKey',
-      },
-    };
-  };
-
-  beforeEach(() => {
-    const container = new Container({ defaultScope: 'Singleton' });
-
-    container.bind(SquizRemoteLogger).toDynamicValue(({ container: c }) => {
-      return new SquizRemoteLogger(
-        () => Promise.resolve(config),
-        c.get(Logger),
-        c.get(HttpRequestBuilderFactory),
-      );
-    });
-    container.bind(Logger).toConstantValue(createLoggerMock());
-    container.bind(HttpRequestBuilderFactory).toSelf();
-    container.bind(HttpClient).toConstantValue(createHttpClientMock());
-
-    httpClient = container.get(HttpClient);
-    logger = container.get(SquizRemoteLogger);
-  });
-
-  describe('batch logging', () => {
-    it('should send logs for particular tenant in one call', async () => {
-      jest
-        .spyOn(httpClient, 'sendRequest')
-        .mockResolvedValueOnce(new HttpResponse({ statusCode: 201, body: {} }))
-        .mockResolvedValueOnce(new HttpResponse({ statusCode: 201, body: {} }));
-      const logs = [
-        {
-          level: RemoteLogLevel.INFO,
-          message: faker.word.words(),
-          timestamp: faker.date.past(),
-          tenantId: new TenantId('1'),
-        },
-        {
-          level: RemoteLogLevel.INFO,
-          message: faker.word.words(),
-          timestamp: faker.date.past(),
-          tenantId: new TenantId('1'),
-        },
-        {
-          level: RemoteLogLevel.INFO,
-          message: faker.word.words(),
-          timestamp: faker.date.past(),
-          tenantId: new TenantId('2'),
-        },
-      ] as const;
-
-      await logger.log(logs);
-
-      expect(httpClient.sendRequest).toHaveBeenCalledWith(
-        expectedPayload('1', [
-          {
-            level: 'INFO',
-            message: logs[0].message,
-            timestamp: logs[0].timestamp.toISOString(),
-            service: 'experiment',
-          },
-          {
-            level: 'INFO',
-            message: logs[1].message,
-            timestamp: logs[1].timestamp.toISOString(),
-            service: 'experiment',
-          },
-        ]),
-      );
-      expect(httpClient.sendRequest).toHaveBeenCalledWith(
-        expectedPayload('2', [
-          {
-            level: 'INFO',
-            message: logs[2].message,
-            timestamp: logs[2].timestamp.toISOString(),
-            service: 'experiment',
-          },
-        ]),
-      );
-    });
-  });
-
-  describe('simple logging', () => {
-    const log = {
-      message: faker.word.words(),
-      timestamp: faker.date.past(),
-      tenantId: new TenantId('1'),
-    };
-
-    beforeEach(() => {
-      jest.spyOn(httpClient, 'sendRequest').mockResolvedValueOnce(
-        new HttpResponse({
-          statusCode: 201,
-          body: {},
-        }),
-      );
-    });
-
-    it('should send INFO log', async () => {
-      await logger.info(log);
-
-      expect(httpClient.sendRequest).toHaveBeenCalledWith(
-        expectedPayload(log.tenantId.valueOf(), [
-          {
-            message: log.message,
-            timestamp: log.timestamp.toISOString(),
-            level: 'INFO',
-            service: 'experiment',
-          },
-        ]),
-      );
-    });
-
-    it('should send WARN log', async () => {
-      await logger.warn(log);
-
-      expect(httpClient.sendRequest).toHaveBeenCalledWith(
-        expectedPayload(log.tenantId.valueOf(), [
-          {
-            message: log.message,
-            timestamp: log.timestamp.toISOString(),
-            level: 'WARNING',
-            service: 'experiment',
-          },
-        ]),
-      );
-    });
-
-    it('should send ERROR log', async () => {
-      await logger.error(log);
-
-      expect(httpClient.sendRequest).toHaveBeenCalledWith(
-        expectedPayload(log.tenantId.valueOf(), [
-          {
-            message: log.message,
-            timestamp: log.timestamp.toISOString(),
-            level: 'ERROR',
-            service: 'experiment',
-          },
-        ]),
-      );
-    });
-  });
-});

package/src/validation/handleValidation.ts

@@ -1,13 +0,0 @@
-import { SafeParseReturnType } from 'zod';
-import { ValidationException } from '../exception/DomainException';
-
-export function handleValidation<T, O>(
-  safeParseResult: SafeParseReturnType<T, O>,
-  errorMessage = 'Validation Failed',
-): O {
-  if (!safeParseResult.success) {
-    throw new ValidationException(errorMessage, safeParseResult.error.issues);
-  }
-
-  return safeParseResult.data;
-}

package/src/valueObject/TenantId.ts

@@ -1,27 +0,0 @@
-import { z } from 'zod';
-import { handleValidation } from '../validation/handleValidation';
-
-export const TENANT_ID_SCHEMA = z.string().min(1);
-
-export type TenantIdValue = z.infer<typeof TENANT_ID_SCHEMA>;
-
-export class TenantId {
-  static parse(data: unknown): TenantId {
-    return new TenantId(
-      handleValidation(
-        TENANT_ID_SCHEMA.safeParse(data),
-        'The validation of tenant id failed',
-      ),
-    );
-  }
-
-  constructor(private readonly value: TenantIdValue) {}
-
-  valueOf(): TenantIdValue {
-    return this.value;
-  }
-
-  equals(tenantId: TenantId): boolean {
-    return this.value === tenantId.value;
-  }
-}