feat(core): add internalExtension activity logger and can be injected into cacheLayerLoader

Author: onlyjackfrost

packages/core/src/containers/modules/extension.ts

@@ -3,6 +3,7 @@ import { ExtensionLoader } from '../../lib/extension-loader';
 import { ICoreOptions } from '../../models/coreOptions';
 import templateEngineModules from '../../lib/template-engine/built-in-extensions';
 import validatorModule from '../../lib/validators/built-in-validators';
+import LoggerModule from '../../lib/loggers';
 import {
   builtInCodeLoader,
   builtInTemplateProvider,
@@ -23,6 +24,7 @@ export const extensionModule = (options: ICoreOptions) =>
     for (const templateEngineModule of templateEngineModules) {
       loader.loadInternalExtensionModule(templateEngineModule);
     }
+    loader.loadInternalExtensionModule(LoggerModule);
     // Validator (single module)
     loader.loadInternalExtensionModule(validatorModule);
     // Template provider (single module)

packages/core/src/containers/types.ts

@@ -52,4 +52,6 @@ export const TYPES = {
   Extension_CompilerLoader: Symbol.for('Extension_CompilerLoader'),
   Extension_DataSource: Symbol.for('Extension_DataSource'),
   Extension_ProfileReader: Symbol.for('ProfileReader'),
+  // Logger
+  Extension_ActivityLogger: Symbol.for('Extension_ActivityLogger'),
 };

packages/core/src/lib/cache-layer/cacheLayerLoader.ts

@@ -4,6 +4,7 @@ import * as moment from 'moment';
 import { inject, injectable, interfaces } from 'inversify';
 import { TYPES } from '@vulcan-sql/core/types';
 import {
+  IActivityLogger,
   CacheLayerInfo,
   ICacheLayerOptions,
   cacheProfileName,
@@ -22,16 +23,19 @@ export class CacheLayerLoader implements ICacheLayerLoader {
   private options: ICacheLayerOptions;
   private cacheStorage: DataSource;
   private logger = getLogger({ scopeName: 'CORE' });
-
+  private activityLoggers: IActivityLogger;
   constructor(
     @inject(TYPES.CacheLayerOptions) options: CacheLayerOptions,
     @inject(TYPES.Factory_DataSource)
-    dataSourceFactory: interfaces.SimpleFactory<DataSource>
+    dataSourceFactory: interfaces.SimpleFactory<DataSource>,
+    @inject(TYPES.Extension_ActivityLogger)
+    activityLogger: IActivityLogger
   ) {
     this.dataSourceFactory = dataSourceFactory;
     this.options = options;
     // prepare cache data source
     this.cacheStorage = this.dataSourceFactory(cacheProfileName);
+    this.activityLoggers = activityLogger;
   }
 
   /**
@@ -46,6 +50,7 @@ export class CacheLayerLoader implements ICacheLayerLoader {
     const { cacheTableName, sql, profile, indexes, folderSubpath } = cache;
     const type = this.options.type!;
     const dataSource = this.dataSourceFactory(profile);
+    await this.activityLoggers.log({ a: 1 });
 
     // generate directory for cache file path to export
     // format => [folderPath]/[schema.templateSource]/[profileName]/[cacheTableName]]/[timestamp]

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

@@ -0,0 +1,41 @@
+import {
+  BaseActivityLogger,
+  ActivityLoggerType,
+} from '../../models/extensions/logger';
+import {
+  VulcanExtensionId,
+  VulcanInternalExtension,
+} from '../../models/extensions';
+import axios from 'axios';
+
+interface HttpLoggerConfig {
+  connection?: HttpLoggerConnectionConfig;
+}
+
+interface HttpLoggerConnectionConfig {
+  protocol?: string | undefined;
+  host?: string | undefined;
+  port?: number | string;
+  path?: string | undefined;
+  headers?: NodeJS.Dict<string | string[]> | undefined;
+}
+
+@VulcanInternalExtension('activity-log')
+@VulcanExtensionId(ActivityLoggerType.HTTP_LOGGER)
+export class HttpLogger extends BaseActivityLogger<HttpLoggerConfig> {
+  public async log(payload: any): Promise<void> {
+    const option = this.getOptions();
+    if (!option) {
+      throw new Error('Http logger option is not defined.');
+    }
+    // TODO-ac: should implement http logger
+    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 });
+    } catch (err) {
+      console.error(err);
+    }
+  }
+}

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

@@ -0,0 +1,3 @@
+import { HttpLogger } from './httpLogger';
+
+export default [HttpLogger];

packages/core/src/models/coreOptions.ts

@@ -1,6 +1,7 @@
 import { IArtifactBuilderOptions } from './artifactBuilderOptions';
 import { ICacheLayerOptions } from './cacheLayerOptions';
 import { IDocumentOptions } from './documentOptions';
+import { IActivityLoggerOptions } from './loggerOptions';
 import { IProfilesLookupOptions } from './profilesLookupOptions';
 import { ITemplateEngineOptions } from './templateEngineOptions';
 
@@ -24,6 +25,7 @@ export interface ICoreOptions {
   extensions?: ExtensionAliases;
   document?: IDocumentOptions;
   profiles?: IProfilesLookupOptions;
+  'activity-log'?: IActivityLoggerOptions;
   cache?: ICacheLayerOptions;
   [moduleAlias: string]: any;
 }

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

@@ -12,3 +12,4 @@ export * from './persistentStore';
 export * from './codeLoader';
 export * from './dataSource';
 export * from './profileReader';
+export * from './logger';

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

@@ -0,0 +1,29 @@
+import { ExtensionBase } from './base';
+import { TYPES } from '@vulcan-sql/core/types';
+import { VulcanExtension } from './decorators';
+
+export enum ActivityLoggerType {
+  HTTP_LOGGER = 'http-logger',
+}
+
+export interface IActivityLogger {
+  log(content: any): Promise<void>;
+}
+
+@VulcanExtension(TYPES.Extension_ActivityLogger, { enforcedId: true })
+export abstract class BaseActivityLogger<ActivityLoggerTypeOption>
+  extends ExtensionBase
+  implements IActivityLogger
+{
+  public abstract log(context: any): Promise<void>;
+
+  protected getOptions(): ActivityLoggerTypeOption | undefined {
+    if (!this.getConfig()) return undefined;
+    if (!this.getConfig()['options']) return undefined;
+    const option = this.getConfig()['options'][
+      this.getExtensionId()!
+    ] as ActivityLoggerTypeOption;
+
+    return option;
+  }
+}

packages/core/src/models/index.ts

@@ -8,3 +8,4 @@ export * from './documentOptions';
 export * from './profilesLookupOptions';
 export * from './cacheLayerOptions';
 export * from './profile';
+export * from './loggerOptions';

packages/core/src/models/loggerOptions.ts

@@ -0,0 +1,4 @@
+export interface IActivityLoggerOptions {
+  // different logger type settings
+  [loggerType: string]: any;
+}