@squiz/optimization-utils 1.0.0

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

@@ -0,0 +1,185 @@
+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/package.ts

@@ -0,0 +1,23 @@
+export * from './valueObject/TenantId';
+export * from './validation/handleValidation';
+export * from './typesUtils/utilities';
+export * from './typesUtils/DynamoDB';
+export * from './testing/mock';
+export * from './scheduler/Scheduler';
+export * from './scheduler/EventBridgeScheduler';
+export * from './logger/SquizRemoteLogger';
+export * from './logger/RemoteLogger';
+export * from './logger/LoggerMessage';
+export * from './logger/Logger';
+export * from './httpClient/HttpRequestBuilder';
+export * from './httpClient/HttpClient';
+export * from './httpClient/FetchHttpClient';
+export * from './exception/DomainException';
+export * from './event/DynamoDBEventMapper';
+export * from './event/DomainEvent';
+export * from './event/AggregateRoot';
+export * from './date/DateManipulator';
+export * from './config/ConfigurationLoader';
+export * from './cloudflare/ImplCloudflareKVHttpService';
+export * from './cloudflare/CloudflareKVHttpService';
+export * from './event/EventHandler';

package/src/scheduler/EventBridgeScheduler.ts

@@ -0,0 +1,177 @@
+import { injectable } from 'inversify';
+import {
+  CreateScheduleCommand,
+  DeleteScheduleCommand,
+  FlexibleTimeWindowMode,
+  GetScheduleCommand,
+  ResourceNotFoundException,
+  SchedulerClient,
+} from '@aws-sdk/client-scheduler';
+import { DomainEvent } from '../event/DomainEvent';
+import { PutItemCommandInput } from '@aws-sdk/client-dynamodb';
+import { eventToDynamoDB } from '../event/DynamoDBEventMapper';
+import { randomUUID } from 'crypto';
+import {
+  ScheduleName,
+  Scheduler,
+  SchedulerOptions,
+} from '../scheduler/Scheduler';
+import { Logger } from '../logger/Logger';
+import { createLog } from '../logger/LoggerMessage';
+import { marshall } from '@aws-sdk/util-dynamodb';
+
+export type EventBridgeSchedulerConfig = {
+  region: string;
+  groupName: string;
+  eventTableName: string;
+  schedulerRole: string;
+};
+
+@injectable()
+export class EventBridgeScheduler implements Scheduler {
+  constructor(
+    private readonly config: EventBridgeSchedulerConfig,
+    private readonly client: SchedulerClient,
+    private readonly logger: Logger,
+  ) {}
+
+  async schedule(
+    domainEvent: DomainEvent,
+    options: SchedulerOptions,
+  ): Promise<void> {
+    const logMessage = createLog()
+      .attachEventName(domainEvent.name)
+      .create(this);
+
+    this.logger.debug(logMessage('started scheduling'));
+    // I putted here "the schedule attributes" because in that way we ensure that every PutItem command
+    // it will create always a new record in dynamoDB
+    const putItemCommand: PutItemCommandInput = {
+      TableName: this.config.eventTableName,
+      Item: {
+        ...eventToDynamoDB(domainEvent),
+        // https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-schedule-context-attributes.html
+        ...marshall({
+          eventId: '<aws.scheduler.execution-id>',
+          time: '<aws.scheduler.scheduled-time>',
+        }),
+      },
+    };
+
+    this.logger.debug(...logMessage('finished mapping to PutItemCommandInput'));
+
+    const scheduleName = this.createScheduleName(options.name);
+    const scheduleExpression = this.createScheduleExpression(options);
+
+    this.logger.debug(
+      ...logMessage(
+        `started calling AWS Scheduler with ScheduleName: ` +
+          `${scheduleName}, ScheduleExpression: ${scheduleExpression}`,
+      ),
+    );
+    await this._deleteSchedule(scheduleName, logMessage);
+    const command = new CreateScheduleCommand({
+      Name: scheduleName,
+      GroupName: this.config.groupName,
+      ScheduleExpression: scheduleExpression,
+      ScheduleExpressionTimezone: 'UTC',
+      State: 'ENABLED',
+      FlexibleTimeWindow: {
+        Mode: FlexibleTimeWindowMode.OFF,
+      },
+      ActionAfterCompletion: 'DELETE',
+      Target: {
+        Arn: 'arn:aws:scheduler:::aws-sdk:dynamodb:putItem',
+        Input: JSON.stringify(putItemCommand),
+        RoleArn: this.config.schedulerRole,
+      },
+      ClientToken: randomUUID(),
+    });
+
+    await this.client.send(command);
+    this.logger.debug(...logMessage('finished calling AWS Scheduler'));
+  }
+
+  private createScheduleName(scheduleName: ScheduleName): string {
+    const truncateString = (str: string, maxLength: number): string =>
+      str.length > maxLength ? str.substring(0, maxLength) : str;
+    const maxLengthOfScheduleName = 64;
+
+    return truncateString(scheduleName, maxLengthOfScheduleName);
+  }
+
+  private createScheduleExpression(options: SchedulerOptions): string {
+    switch (options.type) {
+      case 'at': {
+        const dateString = options.value.toISOString().replace(/\..*/, '');
+
+        return `at(${dateString})`;
+      }
+
+      case 'cron':
+        return `cron(${options.value})`;
+      case 'rate':
+        return `rate(${options.value} ${options.unit})`;
+      default:
+        throw new Error(`Passed unresolved ScheduleOption type.`);
+    }
+  }
+
+  async deleteSchedule(scheduleName: ScheduleName): Promise<void> {
+    const logMessage = createLog()
+      .attachMetadata({ scheduleName })
+      .create(this);
+
+    return this._deleteSchedule(scheduleName, logMessage);
+  }
+
+  private async _deleteSchedule(
+    scheduleName: ScheduleName,
+    logMessage: (message: string) => [string, Record<string, unknown>],
+  ): Promise<void> {
+    const trimmedScheduleName = this.createScheduleName(scheduleName);
+
+    try {
+      this.logger.debug(
+        ...logMessage(
+          `started getting schedule, scheduleName: ${trimmedScheduleName}`,
+        ),
+      );
+
+      const getCommand = new GetScheduleCommand({
+        GroupName: this.config.groupName,
+        Name: trimmedScheduleName,
+      });
+
+      await this.client.send(getCommand);
+
+      this.logger.debug(
+        logMessage(
+          `finished getting schedule, scheduleName: ${trimmedScheduleName}`,
+        ),
+      );
+    } catch (e) {
+      if (e instanceof ResourceNotFoundException) {
+        this.logger.debug(
+          ...logMessage(
+            `the schedule does not exist, skipped deleting existing schedule, scheduleName: ${trimmedScheduleName}`,
+          ),
+        );
+        return;
+      }
+
+      throw e;
+    }
+
+    this.logger.debug(...logMessage('started deleting schedule'));
+
+    const deleteCommand = new DeleteScheduleCommand({
+      GroupName: this.config.groupName,
+      Name: trimmedScheduleName,
+    });
+
+    await this.client.send(deleteCommand);
+
+    this.logger.debug(...logMessage('finished deleting schedule'));
+  }
+}

package/src/scheduler/Scheduler.ts

@@ -0,0 +1,32 @@
+import { DomainEvent } from './../event/DomainEvent';
+import { injectable } from 'inversify';
+
+export type CronExpression =
+  `${string} ${string} ${string} ${string} ${string} ${string}`;
+export type RateUnit = 'minutes' | 'hours' | 'days';
+export type ScheduleName = string;
+export type SchedulerOptions = (
+  | {
+      type: 'at';
+      value: Date;
+    }
+  | {
+      type: 'cron';
+      value: CronExpression;
+    }
+  | {
+      type: 'rate';
+      value: number;
+      unit: RateUnit;
+    }
+) & { name: ScheduleName };
+
+@injectable()
+export abstract class Scheduler {
+  abstract schedule(
+    domainEvent: DomainEvent,
+    options: SchedulerOptions,
+  ): Promise<void>;
+
+  abstract deleteSchedule(scheduleName: ScheduleName): Promise<void>;
+}