@crimson-education/browser-logger 2.0.2 → 3.0.1-pinpoint-middleware.0

package/src/reporters/logReporter.ts

@@ -0,0 +1,86 @@
+import { logger, globalMetadata as globalLogMetadata } from '../logger';
+import { IReporter, LogLevel, ReporterConfigBase, ServiceInfo } from '../types';
+
+export interface LogReporterConfig extends ReporterConfigBase {
+  /**
+   * The fallback log level to apply to all trackEvent calls (if the event's level is not set).
+   * Defaults to info.
+   */
+  trackEventDefaultLevel?: LogLevel;
+  /**
+   * The log level to apply to all addBreadcrumb calls.
+   * Defaults to info.
+   */
+  addBreadcrumbLevel?: LogLevel;
+  /**
+   * The log level to apply to all setRouteName calls.
+   * Defaults to debug.
+   */
+  setRouteNameLevel?: LogLevel;
+  /**
+   * The log level to apply to all setPageName calls.
+   * Defaults to debug.
+   */
+  setPageNameLevel?: LogLevel;
+  /**
+   * The log level to apply to all recordSession calls.
+   * Defaults to debug.
+   */
+  recordSessionLevel?: LogLevel;
+  /**
+   * The log level to apply to all recordSessionStop calls.
+   * Defaults to debug.
+   */
+  recordSessionStopLevel?: LogLevel;
+}
+
+export function logReporter(info: ServiceInfo, config: LogReporterConfig) {
+  const reporter: IReporter = {
+    ...config,
+    trackEvent(event) {
+      // config.trackEventLevel and config.level overrides event.level here, as it is an override, while config.trackEventDefaultLevel is a fallback.
+      const level = event.level ?? config.trackEventDefaultLevel ?? LogLevel.Info;
+      logger.log(level, event.message, {
+        ...(event.metadata ?? {}),
+        ...(event.metrics ?? {}),
+        ...(event.tags ?? {}),
+      });
+    },
+    addBreadcrumb(breadcrumb) {
+      const level = config.addBreadcrumbLevel ?? LogLevel.Info;
+      logger.log(level, breadcrumb.message, {
+        ...(breadcrumb.metadata ?? {}),
+        category: breadcrumb.category,
+      });
+    },
+    addMetadata(metadata) {
+      Object.assign(globalLogMetadata, metadata);
+    },
+    setUser(user) {
+      Object.assign(globalLogMetadata, { user });
+    },
+    setRouteName(routeName) {
+      Object.assign(globalLogMetadata, { routeName });
+      const level = config.setRouteNameLevel ?? LogLevel.Debug;
+      logger.log(level, `Route changed to ${routeName}`);
+    },
+    setPageName(pageName) {
+      Object.assign(globalLogMetadata, { pageName });
+      const level = config.setPageNameLevel ?? LogLevel.Debug;
+      logger.log(level, `Page changed to ${pageName}`);
+    },
+    reportError(error, metadata) {
+      logger.error(typeof error === 'string' ? error : error.message, { ...metadata, error });
+    },
+    recordSession() {
+      const level = config.recordSessionLevel ?? LogLevel.Debug;
+      logger.log(level, 'Recording Session');
+    },
+    recordSessionStop() {
+      const level = config.recordSessionStopLevel ?? LogLevel.Debug;
+      logger.log(level, 'Recording Session Stopping');
+    },
+  };
+
+  return reporter;
+}

package/src/types/logger.ts

@@ -1,6 +1,20 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 export type Metadata = Record<string, any>;
 
+/**
+ * Options to Customize the Logger
+ */
+export type LoggerOptions = {
+  /**
+   * The min log level for events to be sent to the logger.
+   */
+  logLevel?: LogLevel;
+
+  /**
+   * Metadata to add to all logs.
+   */
+  metadata?: Metadata;
+};
+
 export enum LogLevel {
   Debug = 'debug',
   Info = 'info',
@@ -9,20 +23,51 @@ export enum LogLevel {
 }
 
 export interface LogLevelMethod {
-  (message: string, metadata?: any): ILogger;
+  (message: string, metadata?: Metadata): ILogger;
   (message: string, ...meta: any[]): ILogger;
   (message: any): ILogger;
 }
 
 export interface LogMethod {
-  (level: LogLevel, message: string, metadata?: any): ILogger;
+  (level: LogLevel, message: string, metadata?: Metadata): ILogger;
   (level: LogLevel, message: string, ...meta: any[]): ILogger;
   (level: LogLevel, message: any): ILogger;
+  (message: Record<string, any>): ILogger;
 }
 
 export interface Profiler {
   logger: ILogger;
-  done(info?: { message?: string; level?: LogLevel }): boolean;
+  done(info?: { message?: string; level?: LogLevel; metadata?: Metadata }): boolean;
+}
+
+export type StructuredLog = {
+  level: LogLevel;
+  message: any;
+  [key: string]: any;
+};
+
+export interface LogTransportConfigBase {
+  /**
+   * The min log level for logs to be sent.
+   */
+  logLevel?: LogLevel;
+
+  /**
+   * Ignore specific metadata keys from being sent.
+   * This can be a regular expression, or a string to exact match.
+   * This is useful to prevent data of no use for the logger, or if the data keys are too long.
+   */
+  ignoreMetadataPatterns?: (string | RegExp)[];
+}
+
+/**
+ * A logger interface that is used to transport logs to a destination
+ */
+export interface ILogTransport extends LogTransportConfigBase {
+  /**
+   * Inbound log event to transport.
+   */
+  log: (logInfo: StructuredLog) => void;
 }
 
 /**

package/src/types/reporter.ts

@@ -1,6 +1,37 @@
-import { ReporterType } from '..';
+import { AmplifyReporterConfig } from '../reporters/amplifyReporter';
+import { DatadogReporterConfig } from '../reporters/datadogReporter';
+import { GTMReporterConfig } from '../reporters/gtmReporter';
+import { LogReporterConfig } from '../reporters/logReporter';
 import { LogLevel, Metadata } from './logger';
 
+export type ReporterConfigurations = {
+  /**
+   * Log reporter configuration.
+   * If not set, it will default to everything enabled.
+   */
+  log?: boolean | LogReporterConfig;
+
+  /**
+   * Datadog reporter configuration.
+   * If not set, the datadog reporter will not be used.
+   */
+  datadog?: DatadogReporterConfig;
+
+  /**
+   * Amplify/Pinpoint reporter configuration.
+   * If not set, the amplify reporter will not be used.
+   */
+  amplify?: AmplifyReporterConfig;
+
+  /**
+   *  Google Tag Manager reporter configuration.
+   * If not set, the gtm reporter will not be used.
+   */
+  gtm?: true | GTMReporterConfig;
+};
+
+export type ReporterType = keyof ReporterConfigurations;
+
 export type Metrics = Record<string, number>;
 
 export type ServiceInfo = {
@@ -14,6 +45,14 @@ export type ServiceInfo = {
    * Default metadata to add to Reporter events.
    */
   defaultMetadata?: Metadata;
+  /**
+   * The min log level for logs to be sent to the logger.
+   */
+  logLevel?: LogLevel;
+  /**
+   * The min event level for events to be sent to reporters.
+   */
+  eventLevel?: LogLevel;
 };
 
 export type ReportUser = { id: string; email?: string; username?: string; name?: string };
@@ -79,14 +118,35 @@ export interface ReporterBreadcrumb extends ReporterFilters {
 
 export interface ReporterConfigBase {
   /**
-   * Categories of breadcrumbs to ignore sending to Amplify.
-   * This is useful to prevent data of no use for amplify.
+   * Enable/Disable reporter endpoints from being called.
+   */
+  endpoints?: {
+    trackEvent?: boolean;
+    addMetadata?: boolean;
+    addBreadcrumb?: boolean;
+    setUser?: boolean;
+    setRouteName?: boolean;
+    setPageName?: boolean;
+    reportError?: boolean;
+    recordSession?: boolean;
+    recordSessionStop?: boolean;
+  };
+
+  /**
+   * The min event level for events to be sent to the reporter.
+   */
+  eventLevel?: LogLevel;
+
+  /**
+   * Categories of breadcrumbs to ignore sending to the reporter.
+   * This is useful to prevent data of no use for that reporter.
    */
   ignoreBreadcrumbCategories?: string[];
+
   /**
-   * Ignore specific metadata keys from being sent to Amplify.
+   * Ignore specific metadata keys from being sent to the reporter.
    * This can be a regular expression, or a string to exact match.
-   * This is useful to prevent data of no use for amplify, or if the data keys are too long.
+   * This is useful to prevent data of no use for the reporter, or if the data keys are too long.
    */
   ignoreMetadataPatterns?: (string | RegExp)[];
 }
@@ -94,7 +154,7 @@ export interface ReporterConfigBase {
 /**
  * A Reporter is a service that can receive Analytics data.
  */
-export interface IReporter {
+export interface IReporter extends ReporterConfigBase {
   trackEvent(event: ReporterEvent): void;
   addBreadcrumb(breadcrumb: ReporterBreadcrumb): void;
   addMetadata(metadata: Metadata): void;

package/src/utils.test.ts

@@ -1,18 +1,32 @@
-import { filterAttributeMap } from './utils';
+import { filterReporterMetadata } from './utils';
 
 describe('utils', () => {
-  describe('filterAttributeMap', () => {
+  describe('filterReporterMetadata', () => {
     it('should remove attributes which match the ignore patterns', () => {
       const inputAttributeMap = {
         includeme: '5',
         excludeme: 'false',
         differentProp: 'boo',
+        deep: {
+          includeme: '5',
+          excludeme: 'false',
+          deepExcludeStr: 'boo',
+          deepExcludeRegex: 'boo',
+        },
       };
 
-      const filtered = filterAttributeMap(inputAttributeMap, [/exclude/g, /Prop/g]);
-      expect(filtered['includeme']).toBeTruthy();
-      expect(filtered['excludeme']).toBeFalsy();
-      expect(filtered['differentProp']).toBeFalsy();
+      const filtered = filterReporterMetadata(inputAttributeMap, {
+        ignoreMetadataPatterns: [/excludeme/g, /Prop/g, 'deep.deepExcludeStr', /deep\.deepExcludeRegex/g],
+      });
+      expect(filtered.includeme).toBeTruthy();
+      expect(filtered.excludeme).toBeFalsy();
+      expect(filtered.differentProp).toBeFalsy();
+
+      // deep
+      expect(filtered.deep.includeme).toBeTruthy();
+      expect(filtered.deep.excludeme).toBeFalsy();
+      expect(filtered.deep.deepExcludeStr).toBeFalsy();
+      expect(filtered.deep.deepExcludeRegex).toBeFalsy();
     });
   });
 });

package/src/utils.ts

@@ -1,65 +1,40 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { ILogger, Profiler, Metadata, LogLevel } from './types';
-
-export type AttributeMap = Record<string, string[] | string | null>;
-
-export function consoleLogger(name?: string, options?: { metadata?: Metadata }): ILogger {
-  const logger: ILogger = {
-    startTimer(): Profiler {
-      const start = new Date();
-
-      return {
-        logger: this,
-        done: (args) => {
-          const duration = new Date().getTime() - start.getTime();
-          logger[args?.level ?? LogLevel.Info](`${args?.message ?? 'Timer'} completed in: ${duration}`);
-          return true;
-        },
-      };
-    },
-
-    child(metadata?: Record<string, any>, name?: string): ILogger {
-      return consoleLogger(name, { metadata });
-    },
-
-    log: (level: LogLevel, message: string, metadata?: any) => {
-      return logger[level](message, message);
-    },
-
-    debug: (...args: any[]) => {
-      console.debug(...args);
-      return logger;
-    },
-
-    info: (...args: any[]) => {
-      console.log(...args);
-      return logger;
-    },
-
-    warn: (...args: any[]) => {
-      console.warn(...args);
-      return logger;
-    },
-
-    error: (...args: any[]) => {
-      console.error(...args);
-      return logger;
-    },
-  };
-
-  return logger;
-}
-
-export function filterAttributeMap(
-  attributes: AttributeMap | Record<string, string>,
-  ignorePatterns: (string | RegExp)[],
-) {
-  const entries = Object.entries(attributes);
+import { IReporter, Metadata } from './types';
+
+/**
+ * Recursively filter reporter metadata.
+ * @param metadata Deep Metadata to filter.
+ * @param reporter Reporter with filter config.
+ * @param prefix Prefix for recusring nested metadata.
+ * @returns Filtered metadata.
+ */
+export function filterReporterMetadata<TMetadata extends Metadata | undefined>(
+  metadata: TMetadata,
+  reporter: Pick<IReporter, 'ignoreMetadataPatterns'>,
+  prefix?: string,
+): TMetadata {
+  const ignorePatterns = reporter.ignoreMetadataPatterns;
+
+  // No metadata, or no patterns.
+  if (metadata === undefined || !ignorePatterns) {
+    return metadata;
+  }
+
+  const entries = Object.entries(metadata);
 
   return Object.fromEntries(
-    entries.filter(
-      ([key]) => !ignorePatterns.some((pattern) => (typeof pattern === 'string' ? pattern === key : pattern.test(key))),
-    ),
-  );
+    entries
+      .filter(([key]) => {
+        const fullKey = prefix ? prefix + key : key;
+        return !ignorePatterns.some((pattern) =>
+          typeof pattern === 'string' ? pattern === fullKey : pattern.test(fullKey),
+        );
+      })
+      .map(([key, value]) => {
+        if (typeof value === 'object' && value !== null) {
+          const fullKey = prefix ? prefix + key : key;
+          return [key, filterReporterMetadata(value, reporter, `${fullKey}.`)];
+        }
+        return [key, value];
+      }),
+  ) as TMetadata;
 }