@crimson-education/browser-logger 5.0.0-beta.19 → 5.0.0-beta.20

package/src/logger/index.test.ts

@@ -0,0 +1,68 @@
+import { createLogger, setLogLevel as setGlobalLogLevel, logTransports, consoleTransport } from '.';
+import { init } from '..';
+import { addMetadata, setUser } from '../reporters';
+import { LogLevel } from '../types';
+
+// This isn't actually asserting anything.
+// But it ensures that the logs look correct, and no errors get thrown.
+describe('logger', () => {
+  const logger = createLogger({
+    metadata: {
+      service: 'test',
+    },
+  });
+
+  // Manually set the log transports.
+  logTransports.length = 0;
+  const transport = consoleTransport({
+    // So we can see everything.
+    ignoreMetadataPatterns: [],
+  });
+  logTransports.push(transport);
+
+  it('should log', async () => {
+    logger.log({
+      level: 'info',
+      message: 'data',
+    });
+    logger.log({ data: 'obj' });
+    logger.log(LogLevel.Debug, 'level, message', { data: 'obj' });
+    logger.log(LogLevel.Debug, 'level, message, metadata', { data: 'obj' });
+
+    init({
+      service: 'test-service',
+      environment: 'test',
+      version: 'no-version',
+      defaultMetadata: {
+        application: 'test',
+      },
+    });
+
+    const infoLogger = logger.child({ isLevel: 'info' });
+    infoLogger.info('info call, message');
+    infoLogger.info('info call, message, metadata', { data: 'metadataobj' });
+
+    const timer = logger.startTimer();
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    timer.done({ message: 'timer done', metadata: { id: 1 } });
+
+    setGlobalLogLevel(LogLevel.Info);
+    addMetadata({ global: 'metadata' });
+
+    logger.debug('You should not see this');
+    logger.info('You should see this with { global: "metadata" }');
+
+    setGlobalLogLevel(null);
+    setUser({
+      id: '123',
+      email: 'test@example.com',
+    });
+
+    logger.debug('debug call, user metadata');
+
+    transport.logLevel = LogLevel.Info;
+    logger.debug('You should not see this');
+    logger.info('You should see this');
+    transport.logLevel = undefined;
+  });
+});

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

@@ -0,0 +1,61 @@
+import { asAttributeMap } from './amplifyReporter';
+
+describe('amplifyReporter', () => {
+  it('should convert all attribute values to arrays of strings', () => {
+    const testMetadata = { a: 'a', d: ['e', 'f'] };
+    const attributeMap = asAttributeMap(testMetadata);
+
+    expect(attributeMap.a).toEqual(['a']);
+    expect(attributeMap.d).toEqual(['e', 'f']);
+  });
+
+  it('should handle undefined / null attributes', () => {
+    const testMetadata = { a: null, d: undefined };
+    const attributeMap = asAttributeMap(testMetadata);
+
+    expect(attributeMap.a).toBeNull();
+    expect(attributeMap.d).toBeNull();
+  });
+
+  it('should flatten hierarchies', () => {
+    const testMetadata = { foo: { bar: 'baz' } };
+    const attributeMap = asAttributeMap(testMetadata);
+
+    expect(attributeMap['foo.bar']).toEqual(['baz']);
+  });
+
+  it('should stringify non-string array members', () => {
+    const testMetadata = { foo: 5, bar: [{ baz: 'maz' }] };
+    const attributeMap = asAttributeMap(testMetadata);
+
+    expect(attributeMap.foo).toEqual(['5']);
+    expect(typeof attributeMap.bar?.[0]).toEqual('string');
+  });
+
+  it('should truncate attribute names', () => {
+    const testMetadata = { thisIsAVeryVeryLongAttributeNameThatNeedsToBeTruncated: 5 };
+    const attributeMap = asAttributeMap(testMetadata);
+
+    expect(attributeMap.___VeryVeryLongAttributeNameThatNeedsToBeTruncated).toEqual(['5']);
+  });
+
+  it('should truncate attribute values', () => {
+    const testMetadata = {
+      a: 'ThisIsAVeryLongStringThatNeedsToBeTruncatedTo100CharsOrElseThereWillBeAProblemWithSendingTheBeautifulDataToPinpoint',
+    };
+    const attributeMap = asAttributeMap(testMetadata);
+
+    expect(attributeMap.a).toEqual([
+      'ThisIsAVeryLongStringThatNeedsToBeTruncatedTo100CharsOrElseThereWillBeAProblemWithSendingTheBeautifu',
+    ]);
+  });
+
+  it('should not group values into arrays when groupValues===false', () => {
+    const testMetadata = {
+      a: '5',
+    };
+
+    const attributeMap = asAttributeMap(testMetadata, false);
+    expect(attributeMap.a).toEqual('5');
+  });
+});