@autofleet/outbreak 0.1.0-beta-1 → 0.2.0-beta-1

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@autofleet/outbreak",
-  "version": "0.1.0-beta-1",
+  "version": "0.2.0-beta-1",
   "description": "",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
   "scripts": {
     "build": "rm -rf ./dist && tsc",
     "prepublish": "npm run build",

package/src/{http-wrapper/config.ts → config.ts}

@@ -30,7 +30,7 @@ const load = (overrides: Overrides = {}) => {
       'x-request-id',
       'x-variant-id',
     ],
-    headersPrefix = 'x-internal-',
+    headersPrefix = 'x-af-',
   } = overrides;
 
   validateHeaderList(headersToPropagate);

package/src/example.ts

@@ -0,0 +1,39 @@
+import express from 'express';
+import axios from 'axios';
+import winston from 'winston';
+
+import headersTracer from './index';
+
+axios.defaults.adapter = require('axios/lib/adapters/http');
+
+const logger = winston.createLogger({
+  transports: [
+    new winston.transports.Console(),
+  ],
+});
+
+headersTracer({
+  setAndPropagateCorrelationId: true,
+  headersToPropagate: [
+    'x-text',
+  ],
+  headersPrefix: 'x-af-',
+  winstonLogger: logger,
+});
+
+const app = express();
+
+app.all('/', async (req, res) => {
+  const network = axios.create({ baseURL: 'http://localhost:8080/' });
+  const { data } = await network.get('/header-parrot');
+  res.json(data);
+});
+
+app.all('/header-parrot', (req, res) => {
+  logger.info('Test message', { t: 1 });
+  res.json(req.headers);
+});
+
+app.listen(8080, () => {
+  logger.info('App listen');
+});

package/src/{http-wrapper/wrapper.ts → http_wrapper.ts}

@@ -3,7 +3,7 @@ import http from 'http';
 import shortid from 'shortid';
 import { URL } from 'url';
 import express from 'express';
-import { newTrace, getCurrentTrace } from '../tracer';
+import tracer, { newTrace } from './tracer';
 
 const originalHttpCreateServer = http.createServer;
 const originalRequest = http.request;
@@ -14,7 +14,7 @@ function setAndCollectCorrelationId(config, req, res): void {
   if (typeof correlationId === 'undefined') {
     correlationId = shortid.generate();
   }
-  getCurrentTrace().context.set(config.correlationIdHeader, correlationId);
+  tracer.currentTrace.context.set(config.correlationIdHeader, correlationId);
   res.setHeader(config.correlationIdHeader, correlationId);
 }
 
@@ -25,15 +25,15 @@ function collect(req, headers, headersPrefix): void {
 
   [...headers, ...prefixHeaders].forEach((header) => {
     if (typeof req.headers[header] !== 'undefined') {
-      getCurrentTrace().context.set(header, req.headers[header]);
+      tracer.currentTrace.context.set(header, req.headers[header]);
     }
   });
 }
 
 function injectInResponse(response, headers): void {
-  if (getCurrentTrace()) {
+  if (tracer.currentTrace) {
     headers.forEach((header) => {
-      response.setHeader(header, getCurrentTrace().context.get(header));
+      response.setHeader(header, tracer.currentTrace.context.get(header));
     });
   }
 }
@@ -64,14 +64,14 @@ function wrapHttpCreateServer(config) {
 }
 
 function inject(options): void {
-  if (getCurrentTrace()) {
+  if (tracer.currentTrace) {
     if (!options.headers) {
       // eslint-disable-next-line no-param-reassign
       options.headers = {};
     }
-    [...(getCurrentTrace().context.keys())].forEach((header) => {
+    [...(tracer.currentTrace.context.keys())].forEach((header) => {
       // eslint-disable-next-line no-param-reassign
-      options.headers[header] = getCurrentTrace().context.get(header);
+      options.headers[header] = tracer.currentTrace.context.get(header);
     });
   }
 }

package/src/index.ts

@@ -1,8 +1,47 @@
-import headersTracer from './http-wrapper';
-import { newTrace, getCurrentTrace } from './tracer';
+import winston, { format } from 'winston';
 
-export {
-  headersTracer,
-  getCurrentTrace,
-  newTrace,
+import httpWrapper from './http_wrapper';
+import config from './config';
+import * as tracer from './tracer';
+
+interface Options {
+    winstonLogger?: winston.Logger;
+    loggerTraceKey? : string;
+    headersPrefix?: string;
+    setAndPropagateCorrelationId?: boolean;
+    headersToPropagate?: string[];
+}
+
+const addMetadataToLog = (loggerTraceKey) => format((info) => {
+  const currentTrace = tracer.getCurrentTrace();
+  if (currentTrace && currentTrace.context && currentTrace.context.get) {
+    // eslint-disable-next-line no-param-reassign
+    info[loggerTraceKey] = currentTrace.context.get(config.correlationIdHeader);
+  }
+
+  return info;
+});
+
+export default function (options: Options): void {
+  httpWrapper(config.load(options));
+  tracer.enable();
+
+  if (options.winstonLogger) {
+    const traceKey = options.loggerTraceKey || 'traceId';
+    // eslint-disable-next-line no-param-reassign
+    options.winstonLogger.format = format.combine(
+      addMetadataToLog(traceKey)(),
+      options.winstonLogger.format,
+    );
+  }
+}
+
+export const getCurrentContext = (): any => tracer.getCurrentTrace();
+
+export const { newTrace } = tracer;
+
+export const traceTypes = {
+  HTTP_REQUEST: 'httpRequest',
+  WEB_SOCKET: 'webSocket',
+  RABBIT: 'rabbit',
 };

package/src/tracer.ts

@@ -0,0 +1,67 @@
+import asyncHooks from 'async_hooks';
+import uuid from 'uuid';
+
+const prevStates = {};
+
+const tracer = {
+  currentTrace: null,
+  traces: {},
+};
+
+function init(asyncId, type, triggerAsyncId): void {
+  if (tracer.traces[triggerAsyncId]) {
+    tracer.traces[asyncId] = tracer.traces[triggerAsyncId];
+  }
+}
+
+function before(asyncId): void {
+  if (!tracer.traces[asyncId]) {
+    return;
+  }
+  prevStates[asyncId] = tracer.currentTrace;
+  tracer.currentTrace = tracer.traces[asyncId];
+}
+
+function after(asyncId): void {
+  if (!tracer.traces[asyncId]) {
+    return;
+  }
+  tracer.currentTrace = prevStates[asyncId];
+}
+
+function destroy(asyncId): void {
+  if (tracer.traces[asyncId]) {
+    delete tracer.traces[asyncId];
+    delete prevStates[asyncId];
+  }
+}
+
+const hook = asyncHooks.createHook({
+  init, before, after, destroy,
+});
+
+class Trace {
+  id: string;
+
+  type: string;
+
+  context: Map<string, string>;
+
+  constructor(type) {
+    this.id = uuid.v1();
+    this.type = type;
+    this.context = new Map();
+  }
+}
+
+export const newTrace = (type): void => {
+  tracer.currentTrace = new Trace(type);
+  tracer.traces[asyncHooks.executionAsyncId()] = tracer.currentTrace;
+  return tracer.currentTrace;
+};
+
+export const enable = (): asyncHooks.AsyncHook => hook.enable();
+
+export const getCurrentTrace = (): any => tracer.currentTrace || {};
+
+export default tracer;

package/tests/http-wrapper.test.ts

@@ -3,8 +3,7 @@ import http from 'http';
 import axios from 'axios';
 import winston from 'winston';
 
-import headersTracer from '../src/http-wrapper';
-import { headersTracer as a } from '../src/index';
+import headersTracer from '../src/index';
 
 
 const logger = winston.createLogger({
@@ -18,15 +17,15 @@ const generateApp = async (addEndpoints, port) => {
 
   addEndpoints(app);
 
-  const server: http.Server  = await new Promise((resolve) => {
+  const server: http.Server = await new Promise((resolve) => {
     const s = app.listen(port, () => {
-      console.log('Listen on port', port)
+      console.log('Listen on port', port);
       resolve(s);
     });
-  })
+  });
 
   return () => server.close();
-}
+};
 
 describe('E2E', () => {
   it('Basic functionality', async () => {
@@ -42,33 +41,33 @@ describe('E2E', () => {
 
     const closeServer1 = await generateApp((app) => {
       app.get('/', async (req, res) => {
-        const { data: res1 } = await axios.post(`http://localhost:8082`);
-        res.json(res1)
-      })
-    }, 8081)
+        const { data: res1 } = await axios.post('http://localhost:8082');
+        res.json(res1);
+      });
+    }, 8081);
 
     const closeServer2 = await generateApp((app) => {
       app.post('/', (req, res) => {
-        server2TraceId = req.headers['x-trace-id']
+        server2TraceId = req.headers['x-trace-id'];
         res.json({
           value: req.headers['x-test-header'],
-          wkanda: req.headers['x-wakanda-id']
-        })
-      })
-    }, 8082)
+          wkanda: req.headers['x-wakanda-id'],
+        });
+      });
+    }, 8082);
 
-    const { data: res1, headers } = await axios.get(`http://localhost:8081`, {
+    const { data: res1, headers } = await axios.get('http://localhost:8081', {
       headers: {
         'x-test-header': 'testHeader',
-        'x-wakanda-id': 'my-wakanda-id'
-      }
+        'x-wakanda-id': 'my-wakanda-id',
+      },
     });
     closeServer1();
     closeServer2();
 
 
-    expect(headers['x-trace-id']).toEqual(server2TraceId)
-    expect(res1.value).toEqual('testHeader')
-    expect(res1.wkanda).toEqual('my-wakanda-id')
+    expect(headers['x-trace-id']).toEqual(server2TraceId);
+    expect(res1.value).toEqual('testHeader');
+    expect(res1.wkanda).toEqual('my-wakanda-id');
   });
-})
+});

package/src/http-wrapper/index.ts

@@ -1,41 +0,0 @@
-import winston, { format } from 'winston';
-
-import httpWrapper from './wrapper';
-import config from './config';
-import * as tracer from '../tracer';
-
-interface Options {
-    winstonLogger?: winston.Logger;
-    headersPrefix?: string;
-    setAndPropagateCorrelationId?: boolean;
-    headersToPropagate?: string[];
-}
-
-const addMetadataToLog = format((info) => {
-  const currentTrace = tracer.getCurrentTrace();
-  if (currentTrace && currentTrace.context && currentTrace.context.get) {
-    // eslint-disable-next-line no-param-reassign
-    info.traceId = currentTrace.context.get(config.correlationIdHeader);
-  }
-
-  return info;
-});
-
-export default function (options: Options): void {
-  httpWrapper(config.load(options));
-  tracer.enable();
-
-  if (options.winstonLogger) {
-    // eslint-disable-next-line no-param-reassign
-    options.winstonLogger.format = format.combine(
-      addMetadataToLog(),
-      options.winstonLogger.format,
-    );
-  }
-}
-
-export const traceTypes = {
-  HTTP_REQUEST: 'httpRequest',
-  WEB_SOCKET: 'webSocket',
-  RABBIT: 'rabbit',
-};

package/src/tracer/index.ts

@@ -1,60 +0,0 @@
-import asyncHooks from 'async_hooks';
-import uuid from 'uuid';
-
-class Trace {
-  id: string;
-
-  type: string;
-
-  context: Map<string, any>;
-
-  hooks: { [key: string]: Function[] }
-
-  constructor(type) {
-    this.id = uuid.v1();
-    this.type = type;
-    this.context = new Map();
-    this.hooks = {
-      onDestroy: [],
-    }
-  }
-}
-
-const executionContextMap: Map<number, Trace> = new Map();
-
-function init(asyncId, type, triggerAsyncId): void {
-  if (executionContextMap.has(triggerAsyncId)) {
-    executionContextMap.set(asyncId, executionContextMap.get(triggerAsyncId));
-  }
-}
-
-function destroy(asyncId): void {
-  const ecValue = executionContextMap.get(asyncId);
-  if (ecValue) {
-    ecValue.hooks.onDestroy.map((cb) => cb(asyncId, ecValue));
-  }
-  executionContextMap.delete(asyncId);
-}
-
-const hook = asyncHooks.createHook({
-  init, destroy,
-});
-
-export const newTrace = (type): Trace => {
-  const trace = new Trace(type);
-  executionContextMap.set(asyncHooks.executionAsyncId(), trace);
-  return trace;
-};
-
-export const enable = (): asyncHooks.AsyncHook => hook.enable();
-
-export const getCurrentTrace = (): Trace => {
-  const currentContext = executionContextMap.get(asyncHooks.executionAsyncId());
-  if (!currentContext) {
-    return newTrace('initialContext');
-  }
-
-  return currentContext;
-};
-
-export default executionContextMap;