@api3/commons 0.8.0 → 0.9.1

package/src/logger/index.test.ts

@@ -16,114 +16,125 @@ const createTestLogger = (
   return { baseLogger, logger };
 };
 
-describe('log context', () => {
-  it('works with sync functions', () => {
-    const { baseLogger, logger } = createTestLogger();
-
-    logger.runWithContext({ requestId: 'parent' }, () => {
-      logger.debug('parent start');
-      logger.runWithContext({ requestId: 'child' }, () => {
-        logger.debug('child');
-      });
+test('works with sync functions', () => {
+  const { baseLogger, logger } = createTestLogger();
 
-      logger.debug('parent end');
+  logger.runWithContext({ requestId: 'parent' }, () => {
+    logger.debug('parent start');
+    logger.runWithContext({ requestId: 'child' }, () => {
+      logger.debug('child');
     });
 
-    expect(baseLogger.debug).toHaveBeenCalledWith('parent start', { ctx: { requestId: 'parent' } });
-    expect(baseLogger.debug).toHaveBeenCalledWith('child', { ctx: { requestId: 'child' } });
-    expect(baseLogger.debug).toHaveBeenCalledWith('parent end', { ctx: { requestId: 'parent' } });
+    logger.debug('parent end');
   });
 
-  it('works with async functions', async () => {
-    const { baseLogger, logger } = createTestLogger();
+  expect(baseLogger.debug).toHaveBeenCalledWith('parent start', { ctx: { requestId: 'parent' } });
+  expect(baseLogger.debug).toHaveBeenCalledWith('child', { ctx: { requestId: 'child' } });
+  expect(baseLogger.debug).toHaveBeenCalledWith('parent end', { ctx: { requestId: 'parent' } });
+});
 
-    await logger.runWithContext({ requestId: 'parent' }, async () => {
-      logger.debug('parent start');
-      await logger.runWithContext({ requestId: 'child' }, async () => {
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        logger.debug('child');
-      });
+test('works with async functions', async () => {
+  const { baseLogger, logger } = createTestLogger();
 
-      logger.debug('parent end');
+  await logger.runWithContext({ requestId: 'parent' }, async () => {
+    logger.debug('parent start');
+    await logger.runWithContext({ requestId: 'child' }, async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      logger.debug('child');
     });
 
-    expect(baseLogger.debug).toHaveBeenCalledTimes(3);
-    expect(baseLogger.debug).toHaveBeenCalledWith('parent start', { ctx: { requestId: 'parent' } });
-    expect(baseLogger.debug).toHaveBeenCalledWith('child', { ctx: { requestId: 'child' } });
-    expect(baseLogger.debug).toHaveBeenCalledWith('parent end', { ctx: { requestId: 'parent' } });
+    logger.debug('parent end');
   });
 
-  it('works with deeply nested functions', async () => {
-    const { baseLogger, logger } = createTestLogger();
+  expect(baseLogger.debug).toHaveBeenCalledTimes(3);
+  expect(baseLogger.debug).toHaveBeenCalledWith('parent start', { ctx: { requestId: 'parent' } });
+  expect(baseLogger.debug).toHaveBeenCalledWith('child', { ctx: { requestId: 'child' } });
+  expect(baseLogger.debug).toHaveBeenCalledWith('parent end', { ctx: { requestId: 'parent' } });
+});
 
-    await logger.runWithContext({ parent: true }, async () => {
-      logger.debug('parent start');
+test('works with deeply nested functions', async () => {
+  const { baseLogger, logger } = createTestLogger();
 
-      await logger.runWithContext({ A: true }, async () => {
-        logger.debug('A start');
+  await logger.runWithContext({ parent: true }, async () => {
+    logger.debug('parent start');
 
-        await logger.runWithContext({ B: true }, async () => {
-          setTimeout(() => logger.debug('C'), 25);
-          setTimeout(() => logger.debug('D'), 50);
-          setTimeout(() => logger.debug('E'), 75);
+    await logger.runWithContext({ A: true }, async () => {
+      logger.debug('A start');
 
-          await new Promise((resolve) => setTimeout(resolve, 100));
-          logger.debug('B end');
-        });
+      await logger.runWithContext({ B: true }, async () => {
+        setTimeout(() => logger.debug('C'), 25);
+        setTimeout(() => logger.debug('D'), 50);
+        setTimeout(() => logger.debug('E'), 75);
 
-        logger.debug('A end');
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        logger.debug('B end');
       });
 
-      logger.debug('parent end');
+      logger.debug('A end');
     });
 
-    expect(baseLogger.debug).toHaveBeenCalledTimes(8);
-    expect(baseLogger.debug).toHaveBeenCalledWith('parent start', { ctx: { parent: true } });
-    expect(baseLogger.debug).toHaveBeenCalledWith('A start', { ctx: { parent: true, A: true } });
-    expect(baseLogger.debug).toHaveBeenCalledWith('C', { ctx: { parent: true, A: true, B: true } });
-    expect(baseLogger.debug).toHaveBeenCalledWith('D', { ctx: { parent: true, A: true, B: true } });
-    expect(baseLogger.debug).toHaveBeenCalledWith('E', { ctx: { parent: true, A: true, B: true } });
-    expect(baseLogger.debug).toHaveBeenCalledWith('B end', { ctx: { parent: true, A: true, B: true } });
-    expect(baseLogger.debug).toHaveBeenCalledWith('A end', { ctx: { parent: true, A: true } });
-    expect(baseLogger.debug).toHaveBeenCalledWith('parent end', { ctx: { parent: true } });
+    logger.debug('parent end');
   });
 
-  it('throws if the sync callback function throws', () => {
-    const { logger } = createTestLogger();
+  expect(baseLogger.debug).toHaveBeenCalledTimes(8);
+  expect(baseLogger.debug).toHaveBeenCalledWith('parent start', { ctx: { parent: true } });
+  expect(baseLogger.debug).toHaveBeenCalledWith('A start', { ctx: { parent: true, A: true } });
+  expect(baseLogger.debug).toHaveBeenCalledWith('C', { ctx: { parent: true, A: true, B: true } });
+  expect(baseLogger.debug).toHaveBeenCalledWith('D', { ctx: { parent: true, A: true, B: true } });
+  expect(baseLogger.debug).toHaveBeenCalledWith('E', { ctx: { parent: true, A: true, B: true } });
+  expect(baseLogger.debug).toHaveBeenCalledWith('B end', { ctx: { parent: true, A: true, B: true } });
+  expect(baseLogger.debug).toHaveBeenCalledWith('A end', { ctx: { parent: true, A: true } });
+  expect(baseLogger.debug).toHaveBeenCalledWith('parent end', { ctx: { parent: true } });
+});
 
-    expect(() =>
-      logger.runWithContext({}, () => {
-        throw new Error('some-error');
-      })
-    ).toThrow('some-error');
-  });
+test('throws if the sync callback function throws', () => {
+  const { logger } = createTestLogger();
 
-  it('returns rejected promise if the async callback function rejects', async () => {
-    const { logger } = createTestLogger();
+  expect(() =>
+    logger.runWithContext({}, () => {
+      throw new Error('some-error');
+    })
+  ).toThrow('some-error');
+});
 
-    await expect(async () =>
-      // eslint-disable-next-line @typescript-eslint/require-await
-      logger.runWithContext({}, async () => {
-        throw new Error('some-error');
-      })
-    ).rejects.toThrow('some-error');
-  });
+test('returns rejected promise if the async callback function rejects', async () => {
+  const { logger } = createTestLogger();
 
-  it('can log using all variants of logger.error', () => {
-    const { baseLogger, logger } = createTestLogger();
-
-    logger.error('only message');
-    logger.error('message and context', { requestId: 'parent' });
-    logger.error('message and error', new Error('some-error'));
-    logger.error('message, error and context', new Error('some-error'), { requestId: 'parent' });
-
-    expect(baseLogger.error).toHaveBeenNthCalledWith(1, 'only message', undefined);
-    expect(baseLogger.error).toHaveBeenNthCalledWith(2, 'message and context', { ctx: { requestId: 'parent' } });
-    expect(baseLogger.error).toHaveBeenNthCalledWith(3, 'message and error', new Error('some-error'), undefined);
-    expect(baseLogger.error).toHaveBeenNthCalledWith(4, 'message, error and context', new Error('some-error'), {
-      ctx: {
-        requestId: 'parent',
-      },
-    });
+  await expect(async () =>
+    // eslint-disable-next-line @typescript-eslint/require-await
+    logger.runWithContext({}, async () => {
+      throw new Error('some-error');
+    })
+  ).rejects.toThrow('some-error');
+});
+
+test('can log using all variants of logger.error', () => {
+  const { baseLogger, logger } = createTestLogger();
+
+  logger.error('only message');
+  logger.error('message and context', { requestId: 'parent' });
+  logger.error('message and error', new Error('some-error'));
+  logger.error('message, error and context', new Error('some-error'), { requestId: 'parent' });
+
+  expect(baseLogger.error).toHaveBeenNthCalledWith(1, 'only message', undefined);
+  expect(baseLogger.error).toHaveBeenNthCalledWith(2, 'message and context', { ctx: { requestId: 'parent' } });
+  expect(baseLogger.error).toHaveBeenNthCalledWith(3, 'message and error', new Error('some-error'), undefined);
+  expect(baseLogger.error).toHaveBeenNthCalledWith(4, 'message, error and context', new Error('some-error'), {
+    ctx: {
+      requestId: 'parent',
+    },
   });
 });
+
+test('logs an error when passed as context to non error level', () => {
+  const { baseLogger, logger } = createTestLogger();
+  const e = new Error('some-error');
+
+  logger.debug('debug message', e);
+  logger.info('info message', e);
+  logger.warn('warn message', e);
+
+  expect(baseLogger.debug).toHaveBeenCalledWith('debug message', { ctx: { error: 'some-error', name: 'Error' } });
+  expect(baseLogger.info).toHaveBeenCalledWith('info message', { ctx: { error: 'some-error', name: 'Error' } });
+  expect(baseLogger.warn).toHaveBeenCalledWith('warn message', { ctx: { error: 'some-error', name: 'Error' } });
+});

package/src/logger/index.ts

@@ -1,3 +1,4 @@
+import isError from 'lodash/isError';
 import winston from 'winston';
 import { consoleFormat } from 'winston-console-format';
 
@@ -87,10 +88,17 @@ export interface Logger {
   child: (options: { name: string }) => Logger;
 }
 
+const parseLocalContext = (localContext: LogContext | undefined) => {
+  // Sometimes an error passed as a context, but when JS error has no own enumerable properties, so when it is spread
+  // (using ...) we get an empty object and lose all the context.
+  if (isError(localContext)) return { error: localContext.message, name: localContext.name };
+  return localContext;
+};
+
 const createFullContext = (localContext: LogContext | undefined) => {
   const globalContext = getAsyncLocalStorage().getStore();
   if (!globalContext && !localContext) return;
-  const fullContext = { ...globalContext, ...localContext };
+  const fullContext = { ...globalContext, ...parseLocalContext(localContext) };
 
   // If the context contains a `name` or `message` field, it will override the `name` and `message` fields of the log
   // entry. To avoid this, we return the context as a separate field.