@squiz/component-logger-lib 1.32.1-alpha.22 → 1.32.1-alpha.26

package/src/component-logger.spec.ts

@@ -1,20 +1,258 @@
 import { ComponentLogger } from './component-logger';
 import { ComponentLoggerConfig } from './component-logger-config';
-import * as process from 'process';
+import superagent from 'superagent';
+
+const postSetMock = {
+  send: jest.fn(),
+};
+const postMock = {
+  set: () => {
+    return postSetMock;
+  },
+};
+jest.mock('superagent', () => ({
+  post: () => {
+    return postMock;
+  },
+}));
+
+const loggerConfig = <ComponentLoggerConfig>{
+  enabled: true,
+  logUrl: 'some-log-url',
+  key: 'some-key',
+  tenantId: 'some-tenant-id',
+  tags: 'some-tags',
+};
 
 describe('ComponentLogger', () => {
-  it('should allow sending log messages', async () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  beforeAll(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date('2023-05-28T00:00:00.000Z'));
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  it('should throw error if config.logUrl is not set', async () => {
+    const loggerConfig = <ComponentLoggerConfig>{
+      enabled: true,
+      logUrl: '',
+      key: 'some-key',
+      tenantId: 'some-tenant-id',
+      tags: 'some-tags',
+    };
+    expect(() => new ComponentLogger(loggerConfig)).toThrow('config.logUrl is required');
+  });
+
+  it('should throw error if config.key is not set', async () => {
     const config = <ComponentLoggerConfig>{
-      enabled: JSON.parse((process.env.COMPONENT_LOGGER_ENABLED || 'false').toLocaleLowerCase()),
-      logUrl: process.env.COMPONENT_LOGGER_URL,
-      key: process.env.COMPONENT_LOGGER_KEY,
-      tenantId: process.env.COMPONENT_LOGGER_TENANT_ID,
-      tags: process.env.COMPONENT_LOGGER_TAGS,
+      enabled: true,
+      logUrl: 'some-log-url',
+      key: '',
+      tenantId: 'some-tenant-id',
+      tags: 'some-tags',
     };
+    expect(() => new ComponentLogger(config)).toThrow('config.key is required');
+  });
+
+  it('should throw error if config.tenantId is not set', async () => {
+    const loggerConfig = <ComponentLoggerConfig>{
+      enabled: true,
+      logUrl: 'some-log-url',
+      key: 'some-key',
+      tenantId: '',
+      tags: 'some-tags',
+    };
+    expect(() => new ComponentLogger(loggerConfig)).toThrow('config.tenantId is required');
+  });
 
-    const logger = new ComponentLogger(config);
+  it('should set correct log service URL and API key', async () => {
+    const postSpy = jest.spyOn(superagent, 'post');
+    const postSetSpy = jest.spyOn(postMock, 'set');
 
+    const logger = new ComponentLogger(loggerConfig);
     await logger.info('The quick brown fox', '123');
     await logger.flush();
+
+    expect(postSpy).toBeCalledWith('some-log-url/some-tenant-id');
+    expect(postSetSpy).toBeCalledWith('x-api-key', 'some-key');
+  });
+
+  it('should strip off extra "/" on the logUrl', async () => {
+    const loggerConfig = <ComponentLoggerConfig>{
+      enabled: true,
+      logUrl: 'some-log-url/',
+      key: 'some-key',
+      tenantId: 'some-tenant-id',
+      tags: 'some-tags',
+    };
+
+    const postSpy = jest.spyOn(superagent, 'post');
+
+    const logger = new ComponentLogger(loggerConfig);
+    await logger.info('The quick brown fox', '123');
+    await logger.flush();
+
+    expect(postSpy).toBeCalledWith('some-log-url/some-tenant-id');
+  });
+
+  it('should not send message if disabled', async () => {
+    const loggerConfig = <ComponentLoggerConfig>{
+      enabled: false,
+      logUrl: 'some-log-url',
+      key: 'some-key',
+      tenantId: 'some-tenant-id',
+      tags: 'some-tags',
+    };
+    const logger = new ComponentLogger(loggerConfig);
+
+    await logger.warn('this message wont be sent', '123');
+    await logger.flush();
+    expect(postSetMock.send).toBeCalledTimes(0);
+  });
+
+  it('should send the log messages in batch', async () => {
+    const logger = new ComponentLogger(loggerConfig);
+
+    await logger.info('The quick brown fox 1', '123');
+    await logger.info('The quick brown fox 2', '124');
+    await logger.flush();
+
+    const expectedMessages = [
+      {
+        level: 'INFO',
+        service: 'render-runtime',
+        timestamp: '2023-05-28T00:00:00.000Z',
+        message: 'The quick brown fox 1',
+        tags: 'some-tags',
+        traceid: '123',
+      },
+      {
+        level: 'INFO',
+        service: 'render-runtime',
+        timestamp: '2023-05-28T00:00:00.000Z',
+        message: 'The quick brown fox 2',
+        tags: 'some-tags',
+        traceid: '124',
+      },
+    ];
+    expect(postSetMock.send).toBeCalledWith(expectedMessages);
+  });
+
+  it('should json encode the message if not string', async () => {
+    const logger = new ComponentLogger(loggerConfig);
+
+    await logger.warn(['this', 'is', 'not string'], '123');
+    await logger.flush();
+
+    const expectedMessages = [
+      {
+        level: 'WARN',
+        service: 'render-runtime',
+        timestamp: '2023-05-28T00:00:00.000Z',
+        message: '["this","is","not string"]',
+        tags: 'some-tags',
+        traceid: '123',
+      },
+    ];
+    expect(postSetMock.send).toBeCalledWith(expectedMessages);
+  });
+
+  it('should not send message if there is nothing the message queue', async () => {
+    const logger = new ComponentLogger(loggerConfig);
+
+    await logger.flush();
+    expect(postSetMock.send).toBeCalledTimes(0);
+  });
+
+  it('should clear the message queue after sending the message', async () => {
+    const logger = new ComponentLogger(loggerConfig);
+
+    await logger.info('The quick brown fox', '123');
+    // flushing the log messages again should trigger send only once
+    await logger.flush();
+    await logger.flush();
+    await logger.flush();
+    await logger.flush();
+    expect(postSetMock.send).toBeCalledTimes(1);
+  });
+
+  it('should not send message till queue reaching the max message count', async () => {
+    const logger = new ComponentLogger(loggerConfig);
+
+    await logger.info('The quick brown fox', '123');
+    expect(postSetMock.send).toBeCalledTimes(0);
+  });
+
+  it('should automatically flush the queue after reaching the max message count', async () => {
+    const logger = new ComponentLogger(loggerConfig);
+
+    for (let count = 0; count <= 100; count++) {
+      await logger.info('The quick brown fox', `${count}`);
+    }
+    // this should send all 100 messages above in a single go
+    expect(postSetMock.send).toBeCalledTimes(1);
+  });
+
+  it('should send debug message', async () => {
+    const logger = new ComponentLogger(loggerConfig);
+
+    await logger.debug('some debug message', '123');
+    await logger.flush();
+
+    const expectedMessages = [
+      {
+        level: 'DEBUG',
+        service: 'render-runtime',
+        timestamp: '2023-05-28T00:00:00.000Z',
+        message: 'some debug message',
+        tags: 'some-tags',
+        traceid: '123',
+      },
+    ];
+    expect(postSetMock.send).toBeCalledWith(expectedMessages);
+  });
+
+  it('should send warn message', async () => {
+    const logger = new ComponentLogger(loggerConfig);
+
+    await logger.warn('some warn message', '123');
+    await logger.flush();
+
+    const expectedMessages = [
+      {
+        level: 'WARN',
+        service: 'render-runtime',
+        timestamp: '2023-05-28T00:00:00.000Z',
+        message: 'some warn message',
+        tags: 'some-tags',
+        traceid: '123',
+      },
+    ];
+    expect(postSetMock.send).toBeCalledWith(expectedMessages);
+  });
+
+  it('should send error message', async () => {
+    const logger = new ComponentLogger(loggerConfig);
+
+    await logger.error('some error message', '123');
+    await logger.flush();
+
+    const expectedMessages = [
+      {
+        level: 'ERROR',
+        service: 'render-runtime',
+        timestamp: '2023-05-28T00:00:00.000Z',
+        message: 'some error message',
+        tags: 'some-tags',
+        traceid: '123',
+      },
+    ];
+    expect(postSetMock.send).toBeCalledWith(expectedMessages);
   });
 });

package/src/component-logger.ts

@@ -2,6 +2,8 @@ import superagent from 'superagent';
 import { ComponentLogLevel, ComponentLogMessage } from './component-log-message';
 import { ComponentLoggerConfig } from './component-logger-config';
 
+const MESSAGE_BATCH_SIZE = 100;
+
 export class ComponentLogger {
   private batch: Array<ComponentLogMessage> = [];
 
@@ -35,7 +37,7 @@ export class ComponentLogger {
     return this.append('ERROR', message, traceId);
   }
 
-  async append(level: ComponentLogLevel, message: string | any, traceId?: string): Promise<void> {
+  protected async append(level: ComponentLogLevel, message: string | any, traceId?: string): Promise<void> {
     const payload = typeof message == 'string' ? message : JSON.stringify(message);
 
     this.batch.push({
@@ -44,20 +46,20 @@ export class ComponentLogger {
       timestamp: new Date().toISOString(),
       message: payload,
       tags: this.config.tags,
-      traceId: traceId,
+      traceid: traceId,
     });
 
-    if (this.batch.length == 100) {
+    if (this.batch.length == MESSAGE_BATCH_SIZE) {
       await this.flush();
-      this.batch = [];
     }
   }
 
   async flush(): Promise<void> {
     if (this.config.enabled && this.batch.length > 0) {
       try {
-        const url = `${this.config.logUrl}/${this.config.tenantId}`;
-        await superagent.post(url).set('X-API-Key', this.config.key!).send(this.batch);
+        const url = `${this.config.logUrl.replace(/\/+$/, '')}/${this.config.tenantId}`;
+        await superagent.post(url).set('x-api-key', this.config.key).send(this.batch);
+        this.batch = [];
       } catch (err) {
         console.error(err);
         throw err;

package/src/getComponentLogger.spec.ts

@@ -0,0 +1,31 @@
+import { getComponentLogger } from './getComponentLogger';
+import { ComponentLogger } from '.';
+
+describe('getComponentLogger', () => {
+  it('should return the logger object', async () => {
+    const logger: ComponentLogger = await getComponentLogger({
+      enabled: false,
+      accessCredentials: JSON.stringify({
+        url: 'some-url',
+        key: 'some-key',
+      }),
+      tags: 'some-tags',
+      tenantId: 'some-tenant-id',
+    });
+
+    expect(logger).toBeTruthy();
+  });
+
+  it('should throw error if both accessSecret and accessCredential is provided', async () => {
+    const logger = getComponentLogger({
+      enabled: false,
+      accessSecret: 'some-access-secret',
+      accessCredentials: 'some-access-creds',
+      tags: 'some-tags',
+      tenantId: 'some-tenant-id',
+    });
+    await expect(logger).rejects.toThrowError(
+      'Only either of Logging Service API accessSecret or accessCredentials should be provided',
+    );
+  });
+});

package/src/getComponentLogger.ts

@@ -0,0 +1,55 @@
+import { ComponentLogger } from './component-logger';
+import { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
+
+type ApiAccessInfo = {
+  url: string;
+  key: string;
+};
+
+export async function getComponentLogger(config: {
+  enabled: boolean;
+  tenantId: string;
+  accessSecret?: string | false | undefined;
+  accessCredentials?: string | false | undefined;
+  tags: string;
+}) {
+  if (config.accessSecret && config.accessCredentials) {
+    throw new Error('Only either of Logging Service API accessSecret or accessCredentials should be provided');
+  }
+
+  let apiAccessString = '';
+  if (config.enabled) {
+    if (config.accessCredentials) {
+      apiAccessString = config.accessCredentials;
+    } else if (config.accessSecret) {
+      apiAccessString = await getSecretString(config.accessSecret);
+    }
+  }
+  let apiAccessInfo: ApiAccessInfo = {
+    url: '',
+    key: '',
+  };
+  if (apiAccessString.length) {
+    apiAccessInfo = JSON.parse(apiAccessString);
+  }
+
+  return new ComponentLogger({
+    enabled: config.enabled,
+    tenantId: config.tenantId,
+    logUrl: apiAccessInfo.url,
+    key: apiAccessInfo.key,
+    tags: config.tags,
+  });
+}
+
+async function getSecretString(id: string) {
+  const client = new SecretsManagerClient({});
+
+  const result = await client.send(new GetSecretValueCommand({ SecretId: id }));
+
+  if (result.SecretString === undefined) {
+    throw new Error(`Secret ${id} could not be found`);
+  }
+
+  return result.SecretString;
+}

package/src/index.ts

@@ -1 +1,2 @@
 export { ComponentLogger } from './component-logger';
+export { getComponentLogger } from './getComponentLogger';