@apolitical/logger 1.0.1 → 2.0.0-beta.2

package/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+
+## [2.0.0] - 2022-01-18
+### Changed
+- Dependencies
+- Node version
+- Labels definition instead of metadata
+### Added
+- Logger middleware
+
+## [1.0.2] - 2021-07-08
+### Updated
+- Dependencies
+
 ## [1.0.1] - 2021-04-23
 ### Added
 - Cloud function support

package/README.md

@@ -41,14 +41,15 @@ const childLogger = logger.where(__filename, 'debugging');
 childLogger.debug('Accessed:', { count: 0 });
 ```
 
-### The _metadata_ object
+### The _labels_ object
 
-And also, the metadata object allows you to keep extra info along the logger journey:
+And also, the labels allow you to keep extra info along the logger journey:
 
 ```
 const opts = {
-  metadata: {
-    serviceName: 'apolitical-service'
+  labels: {
+    name: 'apolitical-service',
+    version: 'v1.0.0'
   }
 };
 const logger = apoliticalLogger(opts);

package/package.json

@@ -1,26 +1,22 @@
 {
   "name": "@apolitical/logger",
-  "version": "1.0.1",
+  "version": "2.0.0-beta.2",
   "description": "Node.js module to expose Apolitical's logger service",
   "author": "Apolitical Group Limited <engineering@apolitical.co>",
-  "contributors": [
-    "Anouska Hopkins <anouska.hopkins@apolitical.co>",
-    "Antonio Cordasco <antonio.cordasco@apolitical.co>",
-    "Dorothy Yau <dorothy.yau@apolitical.co>",
-    "Laura Hanna-White <laura.hanna-white@apolitical.co>",
-    "Fatimat Gbajabiamila <fatimat.gbajabiamila@apolitical.co>",
-    "Renzo Rozza <renzo.rozza@apolitical.co>",
-    "Rihards Jukna <rihards.jukna@apolitical.co>"
-  ],
   "license": "MIT",
-  "main": "index.js",
+  "main": "src/index.js",
+  "files": [
+    "src"
+  ],
   "scripts": {
     "test": "jest --bail --runInBand",
     "integration-test": "jest --bail --runInBand",
     "unit-test": "jest --bail --runInBand",
     "lint": "eslint --ext .js ./src",
     "format": "prettier --write 'src/**/*.+(js|json)'",
-    "audit": "audit-ci -h"
+    "lint-format": "lint-staged",
+    "audit": "audit-ci -h",
+    "prepare": "husky install"
   },
   "keywords": [
     "Backend",
@@ -28,31 +24,53 @@
     "Node Modules"
   ],
   "dependencies": {
-    "@google-cloud/logging-winston": "4.0.4",
-    "awilix": "4.3.3",
-    "winston": "3.3.3"
+    "@google-cloud/logging-winston": "4.1.1",
+    "awilix": "6.0.0",
+    "winston": "3.4.0"
   },
   "devDependencies": {
-    "audit-ci": "3.2.0",
-    "eslint": "7.24.0",
-    "eslint-config-prettier": "8.2.0",
-    "eslint-plugin-jest": "24.3.5",
-    "eslint-plugin-prettier": "3.4.0",
-    "husky": "4.3.8",
-    "jest": "26.6.3",
-    "lint-staged": "10.5.4",
-    "prettier": "2.2.1"
+    "@apolitical/eslint-config": "1.0.0-beta.0",
+    "audit-ci": "5.1.2",
+    "husky": "7.0.4",
+    "jest": "27.4.7",
+    "jest-junit": "13.0.0",
+    "lint-staged": "12.1.7"
   },
   "engines": {
-    "node": ">=12.20.1"
+    "node": ">=16.13.2"
+  },
+  "eslintConfig": {
+    "extends": "@apolitical/eslint-config/base.config"
   },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged && yarn test"
-    }
+  "prettier": "@apolitical/eslint-config/prettier.config",
+  "jest": {
+    "bail": true,
+    "clearMocks": true,
+    "collectCoverage": true,
+    "collectCoverageFrom": [
+      "src/**/*.js"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "coverageReporters": [
+      "text",
+      "lcov"
+    ],
+    "resetMocks": true,
+    "testEnvironment": "node",
+    "testTimeout": 60000,
+    "maxConcurrency": 1,
+    "maxWorkers": 1,
+    "reporters": [
+      "default",
+      "jest-junit"
+    ],
+    "testResultsProcessor": "jest-junit"
   },
   "lint-staged": {
-    "*.js": "eslint --cache --fix",
-    "*.+(js|json)": "prettier --write"
+    "*.js": "eslint --cache --fix --ignore-path .gitignore",
+    "*.+(js|json)": "prettier --write --ignore-path .gitignore"
   }
 }

package/src/config.js

@@ -9,7 +9,7 @@ module.exports = {
   },
   LOGGER: {
     LOGGING_LEVELS: ['error', 'warn', 'info', 'debug'],
-    ALLOWED_METADATA: ['serviceName', 'requestId'],
+    ALLOWED_LABELS: ['name', 'version'],
     TRANSPORTS: {
       FILE: {
         ERROR_OPTIONS: {

package/src/container.js

@@ -2,28 +2,22 @@
 
 // External Modules
 const { createContainer, asValue, asFunction } = require('awilix');
-
 const path = require('path');
 const winston = require('winston');
 const winstonGoogle = require('@google-cloud/logging-winston');
-
 // Configuration
 const config = require('./config');
-
 // Services
 const loggerService = require('./services/logger.service');
 
 const container = createContainer();
 container.register({
   // External Modules
-
   path: asValue(path),
   winston: asValue(winston),
   winstonGoogle: asValue(winstonGoogle),
-
   // Configuration
   config: asValue(config),
-
   // Services
   loggerService: asFunction(loggerService).singleton(),
 });

package/src/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const { resolve } = require('./container');
+
+const winstonGoogle = resolve('winstonGoogle');
+const loggerService = resolve('loggerService');
+
+module.exports = {
+  createLogger: loggerService,
+  loggerMiddleware: winstonGoogle.express.makeMiddleware,
+};

package/src/services/logger.service.js

@@ -1,79 +1,89 @@
 'use strict';
 
-module.exports = ({ path, winston, winstonGoogle, config }) => ({ logLevel = 'info', metadata = {} }) => {
-  const { LOGGING_LEVELS, ALLOWED_METADATA } = config.LOGGER;
-  const { ERROR_OPTIONS, COMBINED_OPTIONS } = config.LOGGER.TRANSPORTS.FILE;
-  const { CLOUD_FUNCTION, CREDENTIALS } = config.GOOGLE;
+module.exports =
+  ({ path, winston, winstonGoogle, config }) =>
+  ({ logLevel = 'info', labels = {} }) => {
+    const { LOGGING_LEVELS, ALLOWED_LABELS } = config.LOGGER;
+    const { ERROR_OPTIONS, COMBINED_OPTIONS } = config.LOGGER.TRANSPORTS.FILE;
+    const { CLOUD_FUNCTION, CREDENTIALS } = config.GOOGLE;
 
-  function allowedMetadata() {
-    return ALLOWED_METADATA.reduce((acc, cv) => {
-      if (metadata[cv]) {
-        acc[cv] = metadata[cv];
-      }
-      return acc;
-    }, {});
-  }
+    function allowedLabels() {
+      return ALLOWED_LABELS.reduce((acc, cv) => {
+        if (labels[cv]) {
+          acc[cv] = labels[cv];
+        }
+        return acc;
+      }, {});
+    }
 
-  function loggingLevels() {
-    return LOGGING_LEVELS.reduce((acc, cv, idx) => {
-      acc[cv] = idx;
-      return acc;
-    }, {});
-  }
+    function loggingLevels() {
+      return LOGGING_LEVELS.reduce((acc, cv, idx) => {
+        acc[cv] = idx;
+        return acc;
+      }, {});
+    }
 
-  function loggerTransports() {
-    const transports = [];
-    if (config.NODE_ENV === 'production') {
-      if (CLOUD_FUNCTION || CREDENTIALS) {
-        transports.push(new winstonGoogle.LoggingWinston());
+    function loggerTransports() {
+      const transports = [];
+      if (config.NODE_ENV === 'production') {
+        if (CLOUD_FUNCTION || CREDENTIALS) {
+          transports.push(
+            new winstonGoogle.LoggingWinston({
+              labels,
+              serviceContext: {
+                service: labels.name,
+                version: labels.version,
+              },
+            }),
+          );
+        } else {
+          transports.push(new winston.transports.Console());
+        }
       } else {
         transports.push(new winston.transports.Console());
+        transports.push(new winston.transports.File(ERROR_OPTIONS));
+        transports.push(new winston.transports.File(COMBINED_OPTIONS));
       }
-    } else {
-      transports.push(new winston.transports.Console());
-      transports.push(new winston.transports.File(ERROR_OPTIONS));
-      transports.push(new winston.transports.File(COMBINED_OPTIONS));
+      return transports;
     }
-    return transports;
-  }
-
-  function loggerFormat() {
-    return winston.format.combine(winston.format.colorize(), winston.format.simple());
-  }
 
-  function filterFunctionality(logger) {
-    return LOGGING_LEVELS.reduce(
-      (acc, cv) => {
-        acc[cv] = (message, extras = null) => {
-          if (extras) logger[cv](message, extras);
-          else logger[cv](message);
-        };
-        return acc;
-      },
-      { metadata: logger.defaultMeta },
-    );
-  }
+    function loggerFormat() {
+      return winston.format.combine(winston.format.colorize(), winston.format.simple());
+    }
 
-  function createWrapper(logger) {
-    function where(filePath, method) {
-      const file = path.basename(filePath);
-      const childLogger = logger.child({ location: { file, method } });
-      return createWrapper(childLogger);
+    function filterFunctionality(logger) {
+      return LOGGING_LEVELS.reduce(
+        (acc, cv) => {
+          acc[cv] = (message, extras = null) => {
+            if (extras) logger[cv](message, extras);
+            else logger[cv](message);
+          };
+          return acc;
+        },
+        { labels: logger.labels, transports: logger.transports },
+      );
     }
-    function write(message) {
-      logger.info(message);
+
+    function createWrapper(logger) {
+      function where(filePath, method) {
+        const file = path.basename(filePath);
+        const childLogger = logger.child({ labels: { file, method } });
+        return createWrapper(childLogger);
+      }
+      function write(message) {
+        logger.info(message);
+      }
+      const instance = filterFunctionality(logger);
+      return Object.assign(instance, { where, stream: { write } });
     }
-    const instance = filterFunctionality(logger);
-    return Object.assign(instance, { where, stream: { write } });
-  }
 
-  const loggerInstance = winston.createLogger({
-    level: logLevel,
-    levels: loggingLevels(),
-    format: loggerFormat(),
-    defaultMeta: allowedMetadata(),
-    transports: loggerTransports(),
-  });
+    const loggerInstance = winston.createLogger({
+      labels: allowedLabels(),
+      level: logLevel,
+      levels: loggingLevels(),
+      format: loggerFormat(),
+      transports: loggerTransports(),
+    });
 
-  return createWrapper(loggerInstance);
-};
+    return createWrapper(loggerInstance);
+  };

package/.eslintrc

@@ -1,16 +0,0 @@
-{
-  "extends": [
-    "eslint:recommended",
-    "plugin:prettier/recommended",
-    "plugin:jest/recommended"
-  ],
-  "env": {
-    "node": true,
-    "es6": true,
-    "jest": true
-  },
-  "parserOptions": {
-    "ecmaVersion": 2018
-  },
-  "plugins": ["jest"]
-}

package/.gitlab-ci.yml

@@ -1,22 +0,0 @@
-# External jobs
-include:
-  - project: 'apolitical/templates/gitlab-pipelines'
-    ref: master
-    file: 'Node-Testing.gitlab-ci.yml'
-
-stages:
-  - cache
-  - test
-  - publish
-
-publish-module:
-  stage: publish
-  image: node:12.20.1-alpine3.11
-  extends: 
-    - .use-cache
-  only:
-    - tags
-    - /^v\d+\.\d+\.\d+$/  
-  script:
-    - echo '//registry.npmjs.org/:_authToken=${NPM_TOKEN}' > ~/.npmrc
-    - yarn publish --access=public

package/.prettierrc

@@ -1,7 +0,0 @@
-{
-  "useTabs": false,
-  "printWidth": 120,
-  "tabWidth": 2,
-  "singleQuote": true,
-  "trailingComma": "all"
-}

package/index.js

@@ -1,5 +0,0 @@
-'use strict';
-
-const container = require('./src/container');
-
-module.exports = container.resolve('loggerService');

package/jest.config.js

@@ -1,188 +0,0 @@
-// For a detailed explanation regarding each configuration property, visit:
-// https://jestjs.io/docs/en/configuration.html
-
-module.exports = {
-  // All imported modules in your tests should be mocked automatically
-  // automock: false,
-
-  // Stop running tests after the first failure
-  // bail: false,
-
-  // Respect "browser" field in package.json when resolving modules
-  // browser: false,
-
-  // The directory where Jest should store its cached dependency information
-  // cacheDirectory: "/var/folders/w1/bgm1c1j969lf2mfml3w9hf400000gn/T/jest_dx",
-
-  // Automatically clear mock calls and instances between every test
-  clearMocks: true,
-
-  // Indicates whether the coverage information should be collected while executing the test
-  collectCoverage: true,
-
-  // An array of glob patterns indicating a set of files for which coverage
-  // information should be collected
-  collectCoverageFrom: ['src/**/{!(container),}.js'],
-
-  // The directory where Jest should output its coverage files
-  coverageDirectory: 'coverage',
-
-  // An array of regexp pattern strings used to skip coverage collection
-  coveragePathIgnorePatterns: ['/node_modules/'],
-
-  // A list of reporter names that Jest uses when writing coverage reports
-  coverageReporters: ['text', 'lcov'],
-
-  // An object that configures minimum threshold enforcement for coverage results
-  // coverageThreshold: null,
-
-  // Make calling deprecated APIs throw helpful error messages
-  // errorOnDeprecated: false,
-
-  // Force coverage collection from ignored files usin a array of glob patterns
-  // forceCoverageMatch: [],
-
-  // Force Jest to exit after all tests have completed running.
-  // This is useful when resources set up by test code cannot be adequately cleaned up
-  // forceExit: true,
-
-  // A path to a module which exports an async function that is triggered once
-  // before all test suites
-  // globalSetup: '<rootDir>/test/global-setup',
-
-  // A path to a module which exports an async function that is triggered once after all test suites
-  // globalTeardown: null,
-
-  // A set of global variables that need to be available in all test environments
-  // globals: {},
-
-  // An array of directory names to be searched recursively up from the requiring module's location
-  // moduleDirectories: [
-  //   "node_modules"
-  // ],
-
-  // An array of file extensions your modules use
-  // moduleFileExtensions: [
-  //   "js",
-  //   "json",
-  //   "jsx",
-  //   "node"
-  // ],
-
-  // A map from regular expressions to module names that allow to stub out
-  // resources with a single module
-  // moduleNameMapper: {},
-
-  // An array of regexp pattern strings, matched against all module paths
-  // before considered 'visible' to the module loader
-  // modulePathIgnorePatterns: [],
-
-  // Activates notifications for test results
-  // notify: false,
-
-  // An enum that specifies notification mode. Requires { notify: true }
-  // notifyMode: "always",
-
-  // A preset that is used as a base for Jest's configuration
-  // preset: null,
-
-  // Run tests from one or more projects
-  // projects: null,
-
-  // Use this configuration option to add custom reporters to Jest
-  // reporters: undefined,
-
-  // Automatically reset mock state between every test
-  resetMocks: true,
-
-  // Reset the module registry before running each individual test
-  // resetModules: false,
-
-  // A path to a custom resolver
-  // resolver: null,
-
-  // Automatically restore mock state between every test
-  // restoreMocks: false,
-
-  // The root directory that Jest should scan for tests and modules within
-  // rootDir: null,
-
-  // A list of paths to directories that Jest should use to search for files in
-  // roots: [
-  //   "<rootDir>"
-  // ],
-
-  // Allows you to use a custom runner instead of Jest's default test runner
-  // runner: "jest-runner",
-
-  // The paths to modules that run some code to configure or set up the
-  // testing environment before each test
-  // setupFiles: ['<rootDir>/node_modules/regenerator-runtime/runtime'],
-
-  // The path to a module that runs some code to configure or set up the
-  // testing framework before each test
-  // setupTestFrameworkScriptFile: null,
-
-  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
-  // snapshotSerializers: [],
-
-  // The test environment that will be used for testing
-  testEnvironment: 'node',
-
-  // Options that will be passed to the testEnvironment
-  // testEnvironmentOptions: {},
-
-  // Adds a location field to test results
-  // testLocationInResults: false,
-
-  // The glob patterns Jest uses to detect test files
-  // testMatch: [
-  //   "**/__tests__/**/*.js?(x)",
-  //   "**/?(*.)+(spec|test).js?(x)"
-  // ],
-
-  // An array of regexp pattern strings that are matched against all
-  // test paths, matched tests are skipped
-  // testPathIgnorePatterns: [
-  //   "/node_modules/"
-  // ],
-
-  // The regexp pattern Jest uses to detect test files
-  // testRegex: "",
-
-  // This option allows the use of a custom results processor
-  // testResultsProcessor: null,
-
-  // This option allows use of a custom test runner
-  // testRunner: "jasmine2",
-
-  // This option sets the URL for the jsdom environment. It is reflected in
-  // properties such as location.href
-  // testURL: "http://localhost",
-
-  // Setting this value to "fake" allows the use of fake timers for functions such as "setTimeout"
-  // timers: "real",
-
-  // A map from regular expressions to paths to transformers
-  // transform: null,
-
-  // An array of regexp pattern strings that are matched against all source
-  // file paths, matched files will skip transformation
-  // transformIgnorePatterns: [
-  //   "/node_modules/"
-  // ],
-
-  // An array of regexp pattern strings that are matched against all modules
-  // before the module loader will automatically return a mock for them
-  // unmockedModulePathPatterns: undefined,
-
-  // Indicates whether each individual test should be reported during the run
-  // verbose: null,
-
-  // An array of regexp patterns that are matched against all source file paths before
-  // re-running tests in watch mode
-  // watchPathIgnorePatterns: [],
-
-  // Whether to use watchman for file crawling
-  // watchman: true,
-};

package/test/unit/logger/__snapshots__/logger.spec.js.snap

@@ -1,27 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Logger Service Child should create child logger with where method 1`] = `
-Object {
-  "debug": [Function],
-  "error": [Function],
-  "info": [Function],
-  "metadata": Object {
-    "requestId": "some-request-id",
-    "serviceName": "some-service-name",
-  },
-  "stream": Object {
-    "write": [Function],
-  },
-  "warn": [Function],
-  "where": [Function],
-}
-`;
-
-exports[`Logger Service Child should create child using child method 1`] = `
-Object {
-  "location": Object {
-    "file": "logger.spec.js",
-    "method": "test",
-  },
-}
-`;

package/test/unit/logger/container.js

@@ -1,25 +0,0 @@
-'use strict';
-
-const { createContainer, asValue, asFunction } = require('awilix');
-
-// External Modules
-const path = require('path');
-
-// Local Modules
-const config = require('../../../src/config');
-const loggerService = require('../../../src/services/logger.service');
-
-// Stubs
-const winston = require('./stubs/winston.stub');
-const winstonGoogle = require('./stubs/winston.google.stub');
-
-const testContainer = createContainer();
-testContainer.register({
-  path: asValue(path),
-  winston: asValue(winston),
-  winstonGoogle: asValue(winstonGoogle),
-  config: asValue(config),
-  loggerService: asFunction(loggerService).singleton(),
-});
-
-module.exports = testContainer;

package/test/unit/logger/logger.helper.js

@@ -1,43 +0,0 @@
-'use strict';
-
-const container = require('./container');
-
-const winston = container.resolve('winston');
-const config = container.resolve('config');
-
-const loggerOpts = {
-  logLevel: 'info',
-  metadata: {
-    serviceName: 'some-service-name',
-    requestId: 'some-request-id',
-  },
-};
-
-const loggerStub = {
-  defaultMeta: {
-    serviceName: loggerOpts.metadata.serviceName,
-    requestId: loggerOpts.metadata.requestId,
-  },
-  child: jest.fn(),
-};
-
-config.LOGGER.LOGGING_LEVELS.forEach((level) => {
-  loggerStub[level] = jest.fn();
-});
-
-module.exports = {
-  setUp() {
-    loggerStub.child.mockReturnValue(loggerStub);
-    winston.format.combine.mockReturnValue('colorize and simple');
-    winston.format.colorize.mockReturnValue('colorize');
-    winston.format.simple.mockReturnValue('simple');
-    winston.createLogger.mockReturnValue(loggerStub);
-
-    return {
-      logger: {
-        opts: loggerOpts,
-        stub: loggerStub,
-      },
-    };
-  },
-};

package/test/unit/logger/logger.spec.js

@@ -1,122 +0,0 @@
-'use strict';
-
-const container = require('./container');
-
-const config = container.resolve('config');
-const winston = container.resolve('winston');
-const winstonGoogle = container.resolve('winstonGoogle');
-const loggerService = container.resolve('loggerService');
-
-const loggerHelper = require('./logger.helper');
-
-describe('Logger Service', () => {
-  const { LOGGING_LEVELS } = config.LOGGER;
-  let logger = null;
-
-  beforeEach(() => {
-    ({ logger } = loggerHelper.setUp());
-  });
-
-  describe('General', () => {
-    test('should be exposed as function', () => {
-      expect(typeof loggerService).toBe('function');
-    });
-
-    test('should provide logger levels', () => {
-      const instance = loggerService(logger.opts);
-      LOGGING_LEVELS.forEach((level) => {
-        expect(typeof instance[level]).toBe('function');
-      });
-    });
-
-    test('should invoke logger methods with message', () => {
-      const instance = loggerService(logger.opts);
-      LOGGING_LEVELS.forEach((level) => {
-        instance[level]('some-message');
-        expect(logger.stub[level]).toHaveBeenCalledTimes(1);
-        expect(logger.stub[level]).toHaveBeenLastCalledWith('some-message');
-      });
-    });
-
-    test('should invoke logger methods with extras', () => {
-      const instance = loggerService(logger.opts);
-      LOGGING_LEVELS.forEach((level) => {
-        instance[level]('some-message', { bar: 'foo' });
-        expect(logger.stub[level]).toHaveBeenCalledTimes(1);
-        expect(logger.stub[level]).toHaveBeenLastCalledWith('some-message', {
-          bar: 'foo',
-        });
-      });
-    });
-  });
-
-  describe('Transport', () => {
-    test('should use console and files in non-prod envs', () => {
-      loggerService(logger.opts);
-      const params = winston.createLogger.mock.calls[0][0];
-      expect(params.transports.length).toEqual(3);
-      expect(winston.transports.Console).toHaveBeenCalledTimes(1);
-      expect(winston.transports.File).toHaveBeenCalledTimes(2);
-    });
-
-    test('should use console in prod env (without credentials)', () => {
-      config.NODE_ENV = 'production';
-      loggerService(logger.opts);
-      const params = winston.createLogger.mock.calls[0][0];
-      expect(params.transports.length).toEqual(1);
-      expect(winston.transports.Console).toHaveBeenCalledTimes(1);
-    });
-
-    test('should use google winston in prod env (with credentials)', () => {
-      config.NODE_ENV = 'production';
-      config.GOOGLE.CREDENTIALS = 'some-credentials';
-      loggerService(logger.opts);
-      const params = winston.createLogger.mock.calls[0][0];
-      expect(params.transports.length).toEqual(1);
-      expect(winstonGoogle.LoggingWinston).toHaveBeenCalledTimes(1);
-    });
-
-    test('should use google winston in prod env (with cloud function)', () => {
-      config.NODE_ENV = 'production';
-      config.GOOGLE.GOOGLE_CLOUD_FUNCTION = 'true';
-      loggerService(logger.opts);
-      const params = winston.createLogger.mock.calls[0][0];
-      expect(params.transports.length).toEqual(1);
-      expect(winstonGoogle.LoggingWinston).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('Metadata', () => {
-    test('should not use default metadata', () => {
-      loggerService({});
-      const params = winston.createLogger.mock.calls[0][0];
-      expect(params.defaultMeta).toEqual({});
-    });
-
-    test('should use default metadata', () => {
-      loggerService(logger.opts);
-      const params = winston.createLogger.mock.calls[0][0];
-      expect(params.defaultMeta).toEqual({
-        requestId: 'some-request-id',
-        serviceName: 'some-service-name',
-      });
-    });
-  });
-
-  describe('Child', () => {
-    test('should create child logger with where method', () => {
-      const instance = loggerService(logger.opts);
-      const childLogger = instance.where(__filename, 'test');
-      expect(logger.stub.child).toHaveBeenCalledTimes(1);
-      expect(childLogger).toMatchSnapshot();
-    });
-
-    test('should create child using child method', () => {
-      const instance = loggerService(logger.opts);
-      instance.where(__filename, 'test');
-      expect(logger.stub.child).toHaveBeenCalledTimes(1);
-      const params = logger.stub.child.mock.calls[0][0];
-      expect(params).toMatchSnapshot();
-    });
-  });
-});

package/test/unit/logger/stubs/winston.google.stub.js

@@ -1,5 +0,0 @@
-'use strict';
-
-module.exports = {
-  LoggingWinston: jest.fn(),
-};

package/test/unit/logger/stubs/winston.stub.js

@@ -1,14 +0,0 @@
-'use strict';
-
-module.exports = {
-  format: {
-    combine: jest.fn(),
-    colorize: jest.fn(),
-    simple: jest.fn(),
-  },
-  transports: {
-    Console: jest.fn(),
-    File: jest.fn(),
-  },
-  createLogger: jest.fn(),
-};