Add setupFetchTracing() function (#10)

- Separate `setupHttpTracing` into two functions
    - `setupHttpTracing` function for incoming requests
    - `setupFetchTracing` function for outgoing requests
- Refactor to separate files new parameters so that we don't need to expose Node.js typings
- Add tests for these new functions
- Add `node-fetch` devDependency (we use it in tests and examples)

Author: styfle

examples/db-example.ts

@@ -34,7 +34,7 @@ async function getDocumentById(ms: number, childOf: SpanContext) {
 
 // example parent function we wish to trace
 async function handler(req: IncomingMessage, res: ServerResponse) {
-  const { spanContext } = setupHttpTracing({ tracer, req, res });
+  const spanContext = setupHttpTracing({ tracer, req, res });
   console.log(spanContext.toTraceId(), spanContext.toSpanId());
   let statusCode: number;
   let data: any;

examples/routing-example.ts

@@ -4,8 +4,11 @@ import {
   SpanContext,
   DeterministicSampler,
   setupHttpTracing,
+  setupFetchTracing,
 } from '../src/index';
 
+import nodeFetch from 'node-fetch';
+
 const tracer = new Tracer(
   {
     serviceName: 'routing-example',
@@ -56,7 +59,8 @@ async function route(path: string, childOf: SpanContext) {
 
 // example parent function we wish to trace
 async function handler(req: IncomingMessage, res: ServerResponse) {
-  const { spanContext, fetch } = setupHttpTracing({ tracer, req, res });
+  const spanContext = setupHttpTracing({ tracer, req, res });
+  const fetch = setupFetchTracing({ spanContext, fetch: nodeFetch });
   console.log(spanContext.toTraceId(), spanContext.toSpanId());
   let statusCode = 200;
 

package.json

@@ -20,6 +20,7 @@
     "@types/node": "^11.9.4",
     "@types/node-fetch": "^2.1.6",
     "@types/tape": "^4.2.33",
+    "node-fetch": "^2.3.0",
     "prettier": "^1.16.4",
     "tape": "^4.10.1",
     "typescript": "^3.3.3"

src/index.ts

@@ -4,6 +4,7 @@ import * as Tags from './tags';
 import { DeterministicSampler } from './deterministic-sampler';
 import { SamplerBase } from './shared';
 import { setupHttpTracing } from './setup-http';
+import { setupFetchTracing } from './setup-fetch';
 
 export {
   Tracer,
@@ -12,4 +13,5 @@ export {
   DeterministicSampler,
   SamplerBase,
   setupHttpTracing,
+  setupFetchTracing,
 };

src/setup-fetch.ts

@@ -0,0 +1,54 @@
+import { SpanContext } from './span-context';
+import * as Tags from './tags';
+import * as Hdrs from './headers';
+import { Request, RequestInit, Headers } from 'node-fetch';
+type Fetch = (url: string | Request, opts?: RequestInit) => void;
+
+interface SetupFetchTracingOptions<T> {
+  spanContext: SpanContext;
+  fetch?: T;
+}
+
+export function setupFetchTracing<T>(options: SetupFetchTracingOptions<T>): T {
+  const { fetch, spanContext } = options;
+  let fetchOriginal: Fetch;
+  if (fetch) {
+    fetchOriginal = (fetch as unknown) as Fetch;
+  } else {
+    fetchOriginal = require('node-fetch');
+  }
+
+  const fetchTracing = (url: string | Request, opts?: RequestInit) => {
+    if (!opts) {
+      opts = { headers: new Headers() };
+    }
+    const headers = new Headers(opts.headers as any);
+    opts.headers = headers;
+
+    const traceId = spanContext.toTraceId();
+    const parentId = spanContext.toSpanId();
+    const priority = spanContext.getTag(Tags.SAMPLING_PRIORITY);
+
+    headers.set(Hdrs.TRACE_ID, traceId);
+    if (typeof parentId !== 'undefined') {
+      headers.set(Hdrs.PARENT_ID, parentId);
+    }
+    if (typeof priority !== 'undefined') {
+      headers.set(Hdrs.PRIORITY, priority);
+    }
+
+    return fetchOriginal(url, opts);
+  };
+
+  // TS doesn't know about decorated runtime data
+  // so we copy from the original just to be safe.
+  for (const key of Object.keys(fetchOriginal)) {
+    const tracing = fetchTracing as any;
+    const original = fetchOriginal as any;
+    tracing[key] = original[key];
+  }
+
+  fetchTracing.default = fetchTracing;
+
+  return (fetchTracing as unknown) as T;
+}

src/setup-http.ts

@@ -1,22 +1,18 @@
-import { IncomingMessage, ServerResponse } from 'http';
 import { SpanContext } from './span-context';
 import * as Tags from './tags';
 import * as Hdrs from './headers';
 import { Tracer } from './tracer';
-import { SpanOptions, SpanTags } from './shared';
-import FetchTemp, { Request, RequestInit, Headers } from 'node-fetch';
-type Fetch = typeof FetchTemp;
+import { SpanOptions, SpanTags, HttpRequest, HttpResponse } from './shared';
 
 interface SetupHttpTracingOptions {
   name?: string;
   tracer: Tracer;
-  req: IncomingMessage;
-  res: ServerResponse;
-  fetch?: Fetch;
+  req: HttpRequest;
+  res: HttpResponse;
 }
 
 export function setupHttpTracing(options: SetupHttpTracingOptions) {
-  const { name = 'setupHttpTracing', tracer, req, res, fetch } = options;
+  const { name = 'setupHttpTracing', tracer, req, res } = options;
   const spanOptions = getSpanOptions(req);
   const span = tracer.startSpan(name, spanOptions);
   const spanContext = span.context();
@@ -30,17 +26,15 @@ export function setupHttpTracing(options: SetupHttpTracingOptions) {
     span.finish();
   });
 
-  const fetchTracing = setupFetch(fetch, spanContext);
-
-  return { spanContext, fetch: fetchTracing };
+  return spanContext;
 }
 
-function getFirstHeader(req: IncomingMessage, key: string) {
+function getFirstHeader(req: HttpRequest, key: string): string | undefined {
   const value = req.headers[key];
   return Array.isArray(value) ? value[0] : value;
 }
 
-function getSpanOptions(req: IncomingMessage) {
+function getSpanOptions(req: HttpRequest): SpanOptions {
   const tags: SpanTags = {};
   tags[Tags.HTTP_METHOD] = req.method;
   tags[Tags.HTTP_URL] = req.url;
@@ -57,52 +51,5 @@ function getSpanOptions(req: IncomingMessage) {
     childOf = new SpanContext(traceId, parentId, tags);
   }
 
-  const options: SpanOptions = { tags, childOf };
-  return options;
-}
-
-function setupFetch(fetch: Fetch | undefined, spanContext: SpanContext) {
-  let fetchOriginal: Fetch;
-  if (fetch) {
-    fetchOriginal = fetch;
-  } else {
-    fetchOriginal = require('node-fetch');
-  }
-
-  function fetchTracing(url: string | Request, opts?: RequestInit) {
-    if (!opts) {
-      opts = { headers: new Headers() };
-    }
-    const headers =
-      opts.headers instanceof Headers
-        ? opts.headers
-        : new Headers(opts.headers as any);
-
-    const traceId = spanContext.toTraceId();
-    const parentId = spanContext.toSpanId();
-    const priority = spanContext.getTag(Tags.SAMPLING_PRIORITY);
-
-    headers.set(Hdrs.TRACE_ID, traceId);
-    if (typeof parentId !== 'undefined') {
-      headers.set(Hdrs.PARENT_ID, parentId);
-    }
-    if (typeof priority !== 'undefined') {
-      headers.set(Hdrs.PRIORITY, priority);
-    }
-
-    return fetchOriginal(url, opts);
-  }
-
-  fetchTracing.default = fetchTracing;
-  fetchTracing.isRedirect = fetchOriginal.isRedirect;
-
-  // TS doesn't know about decorated runtime data
-  // so we copy from the original just to be safe.
-  for (const key of Object.keys(fetchOriginal)) {
-    const tracing = fetchTracing as any;
-    const original = fetchOriginal as any;
-    tracing[key] = original[key];
-  }
-
-  return fetchTracing;
+  return { tags, childOf };
 }

src/shared.ts

@@ -23,3 +23,14 @@ export interface SpanOptions {
 export interface SamplerBase {
   sample(data: string): boolean;
 }
+
+export interface HttpRequest {
+  headers: { [header: string]: string | string[] | undefined };
+  method?: string;
+  url?: string;
+}
+
+export interface HttpResponse {
+  statusCode: number;
+  on(event: string, listener: () => void): this;
+}

test/dummy-honey.ts

@@ -0,0 +1,36 @@
+import Libhoney, { HoneyEvent, HoneyOptions } from 'libhoney';
+
+const noop = () => {};
+
+interface DummyOptions {
+  addField?: (key: string, value: any) => void;
+  send?: () => void;
+}
+
+class DummyHoney extends Libhoney {
+  private dummyOptions: DummyOptions;
+
+  constructor(options: HoneyOptions, dummyOptions?: DummyOptions) {
+    super(options);
+    this.dummyOptions = dummyOptions || {};
+  }
+
+  newEvent(): HoneyEvent {
+    const { addField, send } = this.dummyOptions;
+    return {
+      addField: addField || noop,
+      send: send || noop,
+    };
+  }
+}
+
+export function newDummyHoney(options?: DummyOptions) {
+  return new DummyHoney(
+    {
+      writeKey: 'test',
+      dataset: 'test',
+      disabled: true,
+    },
+    options,
+  );
+}

test/setup-fetch.test.ts

@@ -0,0 +1,74 @@
+import test from 'tape';
+import { setupFetchTracing } from '../src/setup-fetch';
+import { SpanContext } from '../src/span-context';
+import * as Tags from '../src/tags';
+import * as Hdrs from '../src/headers';
+import { RequestInit, Headers } from 'node-fetch';
+
+test('setup-fetch test empty fetch', t => {
+  t.plan(1);
+  const spanContext = new SpanContext('trace-id', 'span-id', {});
+  const fetch = setupFetchTracing({ spanContext });
+  t.equal(typeof fetch, 'function');
+});
+
+test('setup-fetch test fetch properties', t => {
+  t.plan(1);
+  const spanContext = new SpanContext('trace-id', 'span-id', {});
+  const oldFetch = (_: string) => {};
+  oldFetch.dummy = true;
+  const newFetch = setupFetchTracing({ spanContext, fetch: oldFetch });
+  t.equal(newFetch.dummy, oldFetch.dummy);
+});
+
+test('setup-fetch test fetch response', async t => {
+  t.plan(1);
+  const spanContext = new SpanContext('trace-id', 'span-id', {});
+  const oldFetch = (_: string) => {
+    return 'hello';
+  };
+  const newFetch = setupFetchTracing({ spanContext, fetch: oldFetch });
+  const oldResponse = await oldFetch('fake-url');
+  const newResponse = await newFetch('fake-url');
+  t.equal(newResponse, oldResponse);
+});
+
+test('setup-fetch test fetch headers when empty', async t => {
+  t.plan(3);
+  const spanContext = new SpanContext('trace-id', 'span-id', {
+    [Tags.SAMPLING_PRIORITY]: 99,
+  });
+  const oldFetch = (_: string, opts?: RequestInit) => {
+    if (opts && opts.headers) {
+      const headers =
+        opts.headers instanceof Headers
+          ? opts.headers
+          : new Headers(opts.headers as any);
+      t.equal(headers.get(Hdrs.TRACE_ID), 'trace-id');
+      t.equal(headers.get(Hdrs.PARENT_ID), 'span-id');
+      t.equal(headers.get(Hdrs.PRIORITY), '99');
+    }
+    return 'hello';
+  };
+  const newFetch = setupFetchTracing({ spanContext, fetch: oldFetch });
+  await newFetch('fake-url');
+});
+
+test('setup-fetch test fetch headers when non-empty', async t => {
+  t.plan(4);
+  const spanContext = new SpanContext('trace-id', 'span-id', {
+    [Tags.SAMPLING_PRIORITY]: 99,
+  });
+  const oldFetch = (_: string, opts?: RequestInit) => {
+    if (opts && opts.headers) {
+      const headers = new Headers(opts.headers as any);
+      t.equal(headers.get(Hdrs.TRACE_ID), 'trace-id');
+      t.equal(headers.get(Hdrs.PARENT_ID), 'span-id');
+      t.equal(headers.get(Hdrs.PRIORITY), '99');
+      t.equal(headers.get('x-test-header'), 'the-value');
+    }
+    return 'hello';
+  };
+  const newFetch = setupFetchTracing({ spanContext, fetch: oldFetch });
+  await newFetch('fake-url', { headers: { 'x-test-header': 'the-value' } });
+});