@crimson-education/browser-logger 2.0.2-cognito.2 → 3.0.0

package/src/logger/index.ts

@@ -0,0 +1,139 @@
+/* eslint-disable prefer-rest-params */
+import { ILogger, ILogTransport, LoggerOptions, LogLevel, Metadata, Profiler, StructuredLog } from '../types';
+import { filterReporterMetadata } from '../utils';
+import { consoleTransport } from './consoleTransport';
+import { getLogMessage, isAboveLevel } from './utils';
+
+export * from './consoleTransport';
+export * from './datadogTransport';
+
+export const globalMetadata: Metadata = {};
+
+export const logTransports: ILogTransport[] = [consoleTransport()];
+
+export let globalLogLevel: LogLevel | undefined;
+/**
+ * Sets the global log level.
+ */
+export function setLogLevel(level: LogLevel | null): void {
+  globalLogLevel = level ?? undefined;
+}
+
+/**
+ * Creates a Logger Instance.
+ */
+export function createLogger(options: LoggerOptions = {}): ILogger {
+  const rootMetadata = options.metadata ?? {};
+
+  const logger: ILogger = {
+    // impl loosely based on Winston Logger's dynamic log function
+    // https://github.com/winstonjs/winston/blob/master/lib/winston/logger.js
+    log() {
+      let logInfo: StructuredLog;
+
+      // Optimize for the hotpath of logging JSON literals
+      if (arguments.length === 1) {
+        logInfo = {
+          level: LogLevel.Info,
+          ...arguments[0],
+        };
+      }
+      // Slightly less hotpath, but worth optimizing for.
+      else if (arguments.length === 2) {
+        const [level, message] = Array.from(arguments);
+        if (message && typeof message === 'object') {
+          logInfo = {
+            ...message,
+            level: message.level ?? level,
+          };
+        } else {
+          logInfo = {
+            level,
+            message,
+          };
+        }
+      } else {
+        const [level, message, ...splat] = Array.from(arguments);
+
+        const [meta] = splat;
+        if (typeof meta === 'object' && meta !== null) {
+          logInfo = {
+            ...meta,
+            level,
+            splat: splat.slice(1),
+            message,
+          };
+
+          if (meta.message) {
+            logInfo.message = `${getLogMessage(logInfo.message)} ${getLogMessage(meta.message)}`;
+          }
+          if (meta.stack) {
+            logInfo.stack = meta.stack;
+          }
+        } else {
+          logInfo = {
+            level,
+            splat,
+            message,
+          };
+        }
+      }
+
+      // Check if we should log this message
+      const minLevel = globalLogLevel ?? options.logLevel;
+      if (minLevel && !isAboveLevel(logInfo.level, minLevel)) {
+        return logger;
+      }
+
+      // Add timestamp and root metadata.
+      // Ensure there is a message property.
+      logInfo = {
+        ...globalMetadata,
+        ...rootMetadata,
+        timestamp: new Date().toISOString(),
+        ...logInfo,
+        message: logInfo.message ?? '',
+      };
+
+      for (const transport of logTransports) {
+        if (transport.logLevel) {
+          if (!isAboveLevel(logInfo.level, transport.logLevel)) {
+            continue;
+          }
+        }
+        transport.log({
+          ...filterReporterMetadata(logInfo, transport),
+          // These would break the transport if excluded.
+          level: logInfo.level,
+          message: logInfo.message,
+          splat: logInfo.splat,
+        });
+      }
+      return logger;
+    },
+    child(metadata: Metadata): ILogger {
+      return createLogger({ ...rootMetadata, metadata });
+    },
+    startTimer(): Profiler {
+      const start = new Date();
+
+      return {
+        logger: this,
+        done: ({ message, level, metadata } = {}) => {
+          const duration = new Date().getTime() - start.getTime();
+          logger.log(level ?? LogLevel.Info, message ?? 'Timer Completed', { duration, ...(metadata ?? {}) });
+          return true;
+        },
+      };
+    },
+    // Forward the log levels into the log function, essentially shortcuts.
+    debug: (...args) => logger.log(LogLevel.Debug, ...args),
+    info: (...args) => logger.log(LogLevel.Info, ...args),
+    warn: (...args) => logger.log(LogLevel.Warn, ...args),
+    error: (...args) => logger.log(LogLevel.Error, ...args),
+  };
+
+  return logger;
+}
+
+export const logger = createLogger();

package/src/logger/utils.ts

@@ -0,0 +1,28 @@
+import { LogLevel } from '../types';
+
+/**
+ * Checks if a log level is above the global log level.
+ * @param level The log level to check
+ * @param checkLevel THe log level to check against
+ * @returns Is above the checkLevel?
+ */
+export function isAboveLevel(level: LogLevel, checkLevel: LogLevel): boolean {
+  const levels = [LogLevel.Debug, LogLevel.Info, LogLevel.Warn, LogLevel.Error];
+  return levels.indexOf(level) >= levels.indexOf(checkLevel);
+}
+
+/**
+ * Ensures a message output is a string.
+ * @param message The message to assert is/convert to a string
+ * @returns The message as a string
+ */
+export function getLogMessage(message: any): string {
+  if (typeof message === 'string') {
+    return message;
+  }
+  if (typeof message === 'object' && message !== null) {
+    const data = { ...message };
+    return JSON.stringify(data);
+  }
+  return String(message);
+}

package/src/reporters/amplifyReporter.test.ts

@@ -1,4 +1,4 @@
-import { asAttributeMap, filterAttributeMap } from './amplifyReporter';
+import { asAttributeMap } from './amplifyReporter';
 
 describe('amplifyReporter', () => {
   it('should convert all attribute values to arrays of strings', () => {
@@ -58,17 +58,4 @@ describe('amplifyReporter', () => {
     const attributeMap = asAttributeMap(testMetadata, false);
     expect(attributeMap.a).toEqual('5');
   });
-
-  it('should remove attributes which match the ignore patterns', () => {
-    const inputAttributeMap = {
-      includeme: '5',
-      excludeme: 'false',
-      differentProp: 'boo',
-    };
-
-    const filtered = filterAttributeMap(inputAttributeMap, [/exclude/g, /Prop/g]);
-    expect(filtered['includeme']).toBeTruthy();
-    expect(filtered['excludeme']).toBeFalsy();
-    expect(filtered['differentProp']).toBeFalsy();
-  });
 });

package/src/reporters/amplifyReporter.ts

@@ -1,26 +1,70 @@
-import { IReporter, ReporterBreadcrumb, ReporterEvent } from '.';
-import { Metadata, ReportUser, ServiceInfo } from '../types';
+import {
+  IReporter,
+  Metadata,
+  ReporterBreadcrumb,
+  ReporterConfigBase,
+  ReporterEvent,
+  ReportUser,
+  ServiceInfo,
+} from '../types';
 import { Auth } from '@aws-amplify/auth';
 import { Analytics } from '@aws-amplify/analytics';
+import { logger } from '../logger';
 
-export type AmplifyReporterConfig = {
+/* eslint-disable @typescript-eslint/no-unused-vars */
+type AttributeMap = Record<string, string[] | string | null>;
+
+export interface AmplifyReporterConfig extends ReporterConfigBase {
+  /**
+   * AWS Region for Amplify.
+   */
   region: string;
   /**
-   * The Identity Pool ID to use for reporting, if set to false, Auth.configure is not called.
+   * The Identity Pool Id to use for reporting, if set to false, Auth.configure is not called.
    * This must be called manually for the reporter to work.
    */
   identityPoolId: string | false;
+  /**
+   * The Pinpoint App Id to report to.
+   */
   analyticsAppId: string;
+  /**
+   * The Cognito User Pool to configure in Auth.configure.
+   * If you are using Cognito, it is better to set identityPoolId to false and configure Auth manually.
+   */
+  userPoolId?: string;
+  /**
+   * The Cognito Web Client Id to configure in Auth.configure.
+   * If you are using Cognito, it is better to set identityPoolId to false and configure Auth manually.
+   */
+  userPoolWebClientId?: string;
+
+  /**
+   * If you want to track which page/url in your webapp is the most frequently viewed one, you can use this feature.
+   * It will automatically send events containing url information when the page is visited.
+   */
   autoTrackPageViews?: boolean;
+  /**
+   * If you want to track user interactions with elements on the page, you can use this feature.
+   * All you need to do is attach the specified selectors to your dom element and turn on the auto tracking.
+   */
   autoTrackEvents?: boolean;
+  /**
+   * A web session can be defined in different ways.
+   * To keep it simple we define that the web session is active when the page is not hidden and inactive when the page is hidden.
+   */
   autoTrackSessions?: boolean;
+
+  /**
+   * The data tag prefix to use for attributing HTML elements. Defaults to data-analytics-
+   */
   selectorPrefix?: string;
-  ignoreBreadcrumbCategories?: string[];
+
+  /**
+   * Modify how the reporter sends events to Amplify.
+   */
   buffering?: AmplifyReporterBufferingConfig;
-  userPoolId?: string;
-  userPoolWebClientId?: string;
-  ignoreMetadataPatterns?: RegExp[];
-};
+}
 
 /**
  * Configuration options for the buffering behavior of Pinpoint's event tracker.
@@ -52,7 +96,7 @@ export function amplifyReporter(info: ServiceInfo, config: AmplifyReporterConfig
     appName: info.service,
     service: info.service,
     domain: window.location.host,
-    environment: info.service,
+    environment: info.environment,
     version: info.version,
   });
 
@@ -92,16 +136,11 @@ export function amplifyReporter(info: ServiceInfo, config: AmplifyReporterConfig
             ...event.tags,
           },
           false,
-          config.ignoreMetadataPatterns,
         ) as Record<string, string>,
         metrics: event.metrics,
       });
     },
     addBreadcrumb: function (breadcrumb: ReporterBreadcrumb): void {
-      if (breadcrumb.category && config.ignoreBreadcrumbCategories?.includes(breadcrumb.category)) {
-        return;
-      }
-
       reporter.trackEvent({
         message: breadcrumb.message,
         metadata: {
@@ -111,7 +150,7 @@ export function amplifyReporter(info: ServiceInfo, config: AmplifyReporterConfig
       });
     },
     addMetadata: function (metadata: Metadata): void {
-      Object.assign(allMetadata, asAttributeMap(metadata, true, config.ignoreMetadataPatterns));
+      Object.assign(allMetadata, asAttributeMap(metadata, true));
       Analytics.updateEndpoint({
         attributes: allMetadata,
       }).catch(() => {
@@ -139,29 +178,18 @@ export function amplifyReporter(info: ServiceInfo, config: AmplifyReporterConfig
     setPageName: function (pageName: string): void {
       reporter.addMetadata({ pageName });
     },
-    reportError: function (): void {},
-    recordSession: function (): void {},
-    recordSessionStop: function (): void {},
   };
 
   return reporter;
 }
 
-type AttributeMap = Record<string, string[] | string | null>;
-
 /**
  * Pinpoint has strict attribute name and value length limits
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function asAttributeMap(
-  values: Record<string, any>,
-  groupValues = true,
-  ignorePatterns: RegExp[] = [],
-): AttributeMap {
+export function asAttributeMap(values: Record<string, unknown>, groupValues = true): AttributeMap {
   const attributeMap = buildAttributeMap(values, undefined, groupValues);
-  const filteredAttributeMap = filterAttributeMap(attributeMap, ignorePatterns);
 
-  const checkedEntries = Object.entries(filteredAttributeMap).map(([key, value]) => {
+  const checkedEntries = Object.entries(attributeMap).map(([key, value]) => {
     const truncatedKey = key.length > 50 ? `___${key.slice(-47)}` : key;
     const truncatedValue = Array.isArray(value)
       ? value?.map((val) => val.slice(0, 100)) ?? null
@@ -170,6 +198,14 @@ export function asAttributeMap(
     return [truncatedKey, truncatedValue];
   });
 
+  // Pinpoint only accepts 40 attributes
+  if (checkedEntries.length > 40) {
+    logger.error(`Amplify only allows 40 attributes per event, truncating to 40 attributes`, {
+      attributes: checkedEntries,
+    });
+    checkedEntries.length = 40;
+  }
+
   return Object.fromEntries(checkedEntries);
 }
 
@@ -179,7 +215,6 @@ export function asAttributeMap(
  * all of its values are of type `string[]` to appease Pinpoint.
  */
 export function buildAttributeMap(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   values: Record<string, any>,
   parentKey: string | undefined = undefined,
   groupValues = true,
@@ -206,9 +241,3 @@ export function buildAttributeMap(
 
   return valuesWithStringArrays;
 }
-
-export function filterAttributeMap(attributes: AttributeMap | Record<string, string>, ignorePatterns: RegExp[]) {
-  const entries = Object.entries(attributes);
-
-  return Object.fromEntries(entries.filter(([key]) => !ignorePatterns.some((pattern) => pattern.test(key))));
-}

package/src/reporters/datadogReporter.ts

@@ -1,63 +1,129 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { IReporter, ReporterBreadcrumb, ReporterEvent } from '.';
-import { Metadata, Profiler, ReportError, ReportUser, ServiceInfo } from '../types';
-import { datadogLogs, HandlerType, StatusType } from '@datadog/browser-logs';
+import {
+  IReporter,
+  ReporterBreadcrumb,
+  ReporterEvent,
+  Metadata,
+  ReportError,
+  ReportUser,
+  ServiceInfo,
+  ReporterConfigBase,
+} from '../types';
+import { datadogLogs, HandlerType } from '@datadog/browser-logs';
 import { datadogRum, DefaultPrivacyLevel } from '@datadog/browser-rum';
-import { ILogger, LogLevel } from '..';
+import { logTransports } from '../logger';
+import { DatadogLogTransportConfig, datadogTransport } from '../logger/datadogTransport';
 
-export type DatadogReporterConfig = {
+export interface DatadogReporterConfig extends ReporterConfigBase {
+  /** The RUM application ID. */
   applicationId: string;
+  /** A Datadog client token (Generated in the RUM Page) */
   clientToken: string;
+  /** The Datadog site parameter of your organization. */
+  site: string;
+  /** The Application's version (Overrides the browser logger version) */
   version?: string;
-  site?: string;
+  /** Optional proxy URL */
   proxyUrl?: string;
-  forwardConsoleLogs?: boolean;
-  trackInteractions?: boolean;
+
+  /**
+   * Controls the percentage of overall sessions being tracked. It defaults to 100, so every session is tracked by default.
+   */
   sampleRate?: number;
+  /**
+   * Applied after the overall sample rate, and controls the percentage of sessions tracked as Browser RUM & Session Replay.
+   * It defaults to 100, so every session is tracked as Browser RUM & Session Replay by default.
+   */
   replaySampleRate?: number;
-  defaultPrivacyLevel?: DefaultPrivacyLevel;
+
+  /**
+   * Use a secure session cookie. This disables RUM events sent on insecure (non-HTTPS) connections.
+   */
   useSecureSessionCookie?: boolean;
+  /**
+   * Use a secure cross-site session cookie.
+   * This allows the RUM Browser SDK to run when the site is loaded from another one (iframe). Implies `useSecureSessionCookie`
+   */
   useCrossSiteSessionCookie?: boolean;
-  allowedTracingOrigins?: (string | RegExp)[];
+  /**
+   * Preserve the session across subdomains for the same site.
+   */
   trackSessionAcrossSubdomains?: boolean;
-  actionNameAttribute?: string;
-  trackViewsManually?: boolean;
-};
-
-function getDatadogStatusType(level: LogLevel): StatusType {
-  switch (level) {
-    case LogLevel.Error:
-      return StatusType.error;
-
-    case LogLevel.Warn:
-      return StatusType.warn;
 
-    case LogLevel.Info:
-      return StatusType.info;
+  /**
+   * Forward console.error logs, uncaught exceptions and network errors to Datadog.
+   * Defaults to false.
+   */
+  forwardConsoleLogs?: boolean;
+  /**
+   * Enables automatic collection of users actions.
+   */
+  trackInteractions?: boolean;
+  /**
+   * Enables automatic collection of user frustrations. Implies `trackInteractions`: true.
+   */
+  trackFrustrations?: boolean;
+  /**
+   * Allows you to control RUM views creation.
+   * You will need to call `Logger.setPageName()` to create a new view.
+   */
+  trackViewsManually?: boolean;
+  /**
+   * Specify your own attribute to be used to name actions.
+   * Defaults to `data-analytics-name` to coincide with analytics attributes used across reporters.
+   */
+  actionNameAttribute?: string;
 
-    case LogLevel.Debug:
-    default:
-      return StatusType.debug;
-  }
+  /**
+   * Toggles/configures the Datadog Log Transport.
+   * Defaults to true.
+   */
+  logTransport?: boolean | DatadogLogTransportConfig;
+
+  /**
+   * By enabling Session Replay, you can automatically mask sensitive elements from being recorded through the RUM Browser SDK.
+   *
+   * See https://docs.datadoghq.com/real_user_monitoring/session_replay/privacy_options
+   */
+  defaultPrivacyLevel?: DefaultPrivacyLevel;
+  /**
+   * A list of request origins used to inject tracing headers, to be able to connect RUM and backend tracing.
+   */
+  allowedTracingOrigins?: (string | RegExp)[];
 }
 
 export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig): IReporter {
   const isLocalhost = window.location.hostname === 'localhost';
 
-  datadogLogs.init({
-    site: config.site,
-    proxyUrl: config.proxyUrl,
-    clientToken: config.clientToken,
-    service: info.service,
-    env: info.environment,
-    version: config.version ?? info.version,
-
-    useSecureSessionCookie: config.useSecureSessionCookie ?? !isLocalhost,
-    useCrossSiteSessionCookie: config.useCrossSiteSessionCookie ?? false,
-    trackSessionAcrossSubdomains: config.trackSessionAcrossSubdomains,
+  // Don't forward error logs by default, do enable the log transport by default
+  // forwardErrorsToLogs incorrectly is called forwardConsoleLogs, this is for backwards compatibility
+  const forwardErrorsToLogs = config.forwardConsoleLogs ?? false;
+  const enableLogTransport = config.logTransport !== false;
+
+  // Only init datadog logs if something is using it.
+  if (forwardErrorsToLogs !== true && enableLogTransport !== true) {
+    datadogLogs.init({
+      site: config.site,
+      proxyUrl: config.proxyUrl,
+      clientToken: config.clientToken,
+      service: info.service,
+      env: info.environment,
+      version: config.version ?? info.version,
+
+      sampleRate: config.sampleRate ?? 100,
+
+      useSecureSessionCookie: config.useSecureSessionCookie ?? !isLocalhost,
+      useCrossSiteSessionCookie: config.useCrossSiteSessionCookie ?? false,
+      trackSessionAcrossSubdomains: config.trackSessionAcrossSubdomains,
+
+      forwardErrorsToLogs,
+    });
+    datadogLogs.logger.setHandler(HandlerType.http);
+  }
 
-    forwardErrorsToLogs: config.forwardConsoleLogs ?? false,
-  });
+  // Add the datadog log transport
+  if (enableLogTransport) {
+    logTransports.push(datadogTransport(typeof config.logTransport === 'boolean' ? {} : config.logTransport));
+  }
 
   datadogRum.init({
     site: config.site,
@@ -68,46 +134,49 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
     env: info.environment,
     version: config.version ?? info.version,
 
+    sampleRate: config.sampleRate ?? 100,
+    replaySampleRate: config.replaySampleRate ?? 100,
+
     useSecureSessionCookie: config.useSecureSessionCookie ?? !isLocalhost,
     useCrossSiteSessionCookie: config.useCrossSiteSessionCookie ?? false,
     trackSessionAcrossSubdomains: config.trackSessionAcrossSubdomains,
 
-    // Set sampleRate to 100 to capture 100%
-    // of transactions for performance monitoring.
-    sampleRate: config.sampleRate ?? 100,
-    replaySampleRate: config.replaySampleRate ?? 100,
     trackInteractions: config.trackInteractions ?? false,
+    trackFrustrations: config.trackFrustrations ?? false,
+    trackViewsManually: config.trackViewsManually ?? false,
+    actionNameAttribute: config.actionNameAttribute ?? 'data-analytics-name',
+
     defaultPrivacyLevel: config.defaultPrivacyLevel ?? 'mask-user-input',
     allowedTracingOrigins: config.allowedTracingOrigins,
-    actionNameAttribute: config.actionNameAttribute ?? 'data-analytics-name',
-    trackViewsManually: config.trackViewsManually ?? false,
   });
 
   const reporter: IReporter = {
     trackEvent: function (event: ReporterEvent): void {
-      const context = {
+      datadogRum.addAction(event.message, {
         level: event.level,
         ...event.metadata,
         ...event.tags,
         ...event.metrics,
-      };
-      datadogRum.addAction(event.message, context);
-      datadogLogs.logger?.log(event.message, context, getDatadogStatusType(event.level ?? LogLevel.Info));
+      });
     },
     addBreadcrumb: function (breadcrumb: ReporterBreadcrumb): void {
-      const context = {
+      datadogRum.addAction(breadcrumb.message, {
         ...breadcrumb.metadata,
         category: breadcrumb.category,
-      };
-      datadogRum.addAction(breadcrumb.message, context);
+      });
     },
     addMetadata: function (metadata: Metadata): void {
       for (const [key, value] of Object.entries(metadata)) {
         if (value !== null) {
           datadogRum.addRumGlobalContext(key, value);
+
+          // Note, this will add duplicate context data in logs.
+          // But this is valuable for logs ingested outside of the browser logger.
           datadogLogs.addLoggerGlobalContext(key, value);
         } else {
           datadogRum.removeRumGlobalContext(key);
+
+          // But this is valuable for logs ingested outside of the browser logger.
           datadogLogs.removeLoggerGlobalContext(key);
         }
       }
@@ -119,16 +188,8 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
           email: user.email,
           name: user.name ?? user.email,
         });
-
-        datadogLogs.addLoggerGlobalContext('user_id', user.id);
-        datadogLogs.addLoggerGlobalContext('user_email', user.email);
-        datadogLogs.addLoggerGlobalContext('user_username', user.username);
       } else {
         datadogRum.removeUser();
-
-        datadogLogs.removeLoggerGlobalContext('user_id');
-        datadogLogs.removeLoggerGlobalContext('user_email');
-        datadogLogs.removeLoggerGlobalContext('user_username');
       }
     },
     setRouteName: function (routeName: string): void {
@@ -142,7 +203,6 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
       }
     },
     reportError: function (error: ReportError, metadata?: Metadata): void {
-      // Note, datadog should pick up the console error above
       datadogRum.addError(error, metadata);
     },
     recordSession: function (): void {
@@ -154,55 +214,3 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
   };
   return reporter;
 }
-
-export function datadogLogger(name?: string, options?: { metadata?: Metadata }): ILogger {
-  const loggerName = name ?? 'root';
-  const ddLogger = datadogLogs.createLogger(loggerName, {
-    context: options?.metadata,
-  });
-  // Send to datadog and console.
-  ddLogger.setHandler([HandlerType.http, HandlerType.console]);
-
-  const logger: ILogger = {
-    startTimer: function (): Profiler {
-      const start = new Date();
-
-      return {
-        logger: this,
-        done: ({ message, level } = {}) => {
-          const duration = new Date().getTime() - start.getTime();
-          logger[level ?? LogLevel.Info](message ?? 'Timer Completed', { duration });
-          return true;
-        },
-      };
-    },
-    child: function (metadata?: Metadata, name?: string): ILogger {
-      return datadogLogger(name ?? `${loggerName}.child`, metadata);
-    },
-    log: (level: LogLevel, message: string, metadata?: any) => {
-      switch (level) {
-        case LogLevel.Debug:
-          ddLogger.debug(message, metadata);
-          break;
-
-        case LogLevel.Info:
-          ddLogger.info(message, metadata);
-          break;
-
-        case LogLevel.Warn:
-          ddLogger.warn(message, metadata);
-          break;
-
-        case LogLevel.Error:
-          ddLogger.error(message, metadata);
-          break;
-      }
-      return logger;
-    },
-    debug: (message: string, metadata?: any) => logger.log(LogLevel.Debug, message, metadata),
-    info: (message: string, metadata?: any) => logger.log(LogLevel.Info, message, metadata),
-    warn: (message: string, metadata?: any) => logger.log(LogLevel.Warn, message, metadata),
-    error: (message: string, metadata?: any) => logger.log(LogLevel.Error, message, metadata),
-  };
-  return logger;
-}