implement logger and add test cases

Author: onlyjackfrost

packages/core/src/lib/loggers/httpLogger.ts

@@ -6,36 +6,55 @@ import {
   VulcanExtensionId,
   VulcanInternalExtension,
 } from '../../models/extensions';
-import axios from 'axios';
+import axios, { AxiosRequestHeaders } from 'axios';
+import { ConnectionConfig } from '../utils/url';
 
-interface HttpLoggerConfig {
+export interface HttpLoggerConfig {
   connection?: HttpLoggerConnectionConfig;
 }
 
-interface HttpLoggerConnectionConfig {
-  protocol?: string | undefined;
-  host?: string | undefined;
-  port?: number | string;
-  path?: string | undefined;
-  headers?: NodeJS.Dict<string | string[]> | undefined;
+export interface HttpLoggerConnectionConfig extends ConnectionConfig {
+  headers?: Record<string, string | number | boolean> | undefined;
 }
 
 @VulcanInternalExtension('activity-log')
 @VulcanExtensionId(ActivityLoggerType.HTTP_LOGGER)
 export class HttpLogger extends BaseActivityLogger<HttpLoggerConfig> {
+  private logger = this.getLogger();
+
   public async log(payload: any): Promise<void> {
+    if (!this.isEnabled()) return;
     const option = this.getOptions();
-    if (!option) {
-      throw new Error('Http logger option is not defined.');
+    if (!option?.connection) {
+      throw new Error('Http logger connection should be provided');
     }
-    // TODO-ac: should implement http logger
+    const headers = option.connection.headers;
+    const url = this.getUrl(option.connection);
     try {
       // get connection info from option and use axios to send a post requet to the endpoint
-      const { protocol, host, port, path, headers } = option.connection!;
-      const url = `${protocol}://${host}:${port}${path}`;
-      await axios.post(url, payload, { headers: headers as any });
+      await this.sendActivityLog(url, payload, headers);
     } catch (err) {
-      console.error(err);
+      this.logger.debug(
+        `Failed to send activity log to http logger, url: ${url}`
+      );
+      throw err;
     }
   }
+
+  protected sendActivityLog = async (
+    url: string,
+    payload: JSON,
+    headers: AxiosRequestHeaders | undefined
+  ): Promise<void> => {
+    await axios.post(url, payload, {
+      headers: headers,
+    });
+  };
+
+  protected getUrl = (connection: HttpLoggerConnectionConfig): string => {
+    const { ssl, host, port, path = '' } = connection;
+    const protocol = ssl ? 'https' : 'http';
+    const urlbase = `${protocol}://${host}:${port}`;
+    return new URL(path, urlbase).href;
+  };
 }

packages/core/src/lib/utils/url.ts

@@ -0,0 +1,14 @@
+export interface ConnectionConfig {
+  ssl?: boolean | undefined;
+  host?: string | undefined;
+  port?: number | string;
+  path?: string | undefined;
+}
+
+export const getUrl = (connection: ConnectionConfig): string => {
+  const { ssl, host, port, path = '' } = connection;
+  const protocol = ssl ? 'https' : 'http';
+  let urlbase = `${protocol}://${host}`;
+  urlbase = port ? `${urlbase}:${port}` : urlbase;
+  return new URL(path, urlbase).href;
+};

packages/core/src/models/extensions/logger.ts

@@ -17,13 +17,20 @@ export abstract class BaseActivityLogger<ActivityLoggerTypeOption>
 {
   public abstract log(context: any): Promise<void>;
 
+  protected isEnabled(): boolean {
+    const config = this.getConfig();
+    if (!config) return false;
+    if (config.enabled === true) return true;
+    else return false;
+  }
+
   protected getOptions(): ActivityLoggerTypeOption | undefined {
     if (!this.getConfig()) return undefined;
     if (!this.getConfig()['options']) return undefined;
     const option = this.getConfig()['options'][
       this.getExtensionId()!
     ] as ActivityLoggerTypeOption;
-
+    console.log('option', option);
     return option;
   }
 }

packages/core/test/httplogger.spec.ts

@@ -0,0 +1,77 @@
+import sinon from 'ts-sinon';
+import { HttpLogger } from '../src/lib/loggers/httpLogger';
+class MockHttpLogger extends HttpLogger {
+  public override sendActivityLog = jest.fn();
+}
+const createMockHttpLogger = (config: any) => {
+  return new MockHttpLogger(config, 'httpLogger');
+};
+describe('Activity logs', () => {
+  it('should throw error when logger is enabled but connection is not provided', async () => {
+    const config = {
+      enabled: true,
+      options: {
+        'http-logger': {
+          connection: undefined,
+        },
+      },
+    };
+
+    const httpLogger = createMockHttpLogger(config);
+
+    await expect(httpLogger.log({})).rejects.toThrow(
+      'Http logger connection should be provided'
+    );
+  });
+
+  it('should not throw error when logger is disabled', async () => {
+    const config = {
+      enabled: false,
+    };
+
+    const httpLogger = createMockHttpLogger(config);
+
+    await expect(httpLogger.log({})).resolves.not.toThrow();
+  });
+
+  // should not throw error when logger is enabled and connection is provided
+  it('should not throw error when logger is enabled and connection is provided', async () => {
+    const config = {
+      enabled: true,
+      options: {
+        'http-logger': {
+          connection: {
+            ssl: true,
+            host: 'localhost',
+            port: 8080,
+            path: '/test',
+          },
+        },
+      },
+    };
+    const httpLogger = createMockHttpLogger(config);
+    sinon.stub(httpLogger, 'sendActivityLog').resolves();
+    await expect(httpLogger.log({})).resolves.not.toThrow();
+  });
+
+  // should throw error when logger is enabled and connection is provided but request fails
+  it('should throw error when logger is enabled and connection is provided but request fails', async () => {
+    const config = {
+      enabled: true,
+      options: {
+        'http-logger': {
+          connection: {
+            ssl: true,
+            host: 'localhost',
+            port: 8080,
+            path: '/test',
+          },
+        },
+      },
+    };
+    // stub sendActivityLog to throw error
+    const httpLogger = createMockHttpLogger(config);
+    sinon.stub(httpLogger, 'sendActivityLog').throws();
+    await expect(httpLogger.log({})).rejects.toThrow();
+  });
+});

packages/core/test/utils/url.spec.ts

@@ -0,0 +1,67 @@
+import { get } from 'lodash';
+import { getUrl, ConnectionConfig } from '../../src/lib/utils/url';
+
+describe('url util functions', () => {
+  it('should return url if all connection properties were set', () => {
+    const connection = {
+      ssl: true,
+      host: 'localhost',
+      port: 8080,
+      path: '/test',
+    } as ConnectionConfig;
+
+    const url = getUrl(connection);
+    expect(url).toBe('https://localhost:8080/test');
+  });
+
+  it('should return url if ssl or path is not set', () => {
+    const connection = {
+      host: 'localhost',
+    } as ConnectionConfig;
+
+    const url = getUrl(connection);
+    expect(url).toBe('http://localhost/');
+  });
+
+  it('should return url if host was an IP address', () => {
+    const connection = {
+      ssl: false,
+      host: '127.0.0.1',
+      port: 8080,
+      path: '/test',
+    } as ConnectionConfig;
+    const url = getUrl(connection);
+    expect(url).toBe('http://127.0.0.1:8080/test');
+  });
+
+  it.each([
+    {
+      ssl: false,
+      host: 'localhost',
+      port: 8080,
+      path: '/test',
+    },
+    {
+      host: 'localhost',
+      port: 8080,
+      path: '/test',
+    },
+  ])(
+    'should use protocal http if ssl was not set or set to false',
+    (connection) => {
+      const url = getUrl(connection);
+      expect(url).toBe('http://localhost:8080/test');
+    }
+  );
+
+  it('should return url if host was a DNS name and port was not set', () => {
+    const connection = {
+      ssl: true,
+      host: 'DNSName',
+      path: '/test',
+    } as ConnectionConfig;
+
+    const url = getUrl(connection);
+    expect(url).toBe('https://dnsname/test');
+  });
+});