Stops encouraging serviceName overrides

packages/zipkin-instrumentation-axiosjs/README.md

@@ -27,7 +27,7 @@ const localServiceName = 'service-a'; // name of this application
 const tracer = new Tracer({ ctxImpl, recorder, localServiceName });
 
 const remoteServiceName = 'weather-api';
-const zipkinAxios = wrapAxios(axios, { tracer, serviceName: localServiceName, remoteServiceName });
+const zipkinAxios = wrapAxios(axios, { tracer, remoteServiceName });
 
 zipkinAxios.get('/user?ID=12345')
   .then(function (response) {
@@ -46,11 +46,7 @@ zipkinAxios.get('/user?ID=12345')
     timeout: 1000,
     headers: {'X-Custom-Header': 'foobar'}
 });
-  axiosInstance = wrapAxios(axiosInstance, {
-    tracer,
-    serviceName: localServiceName,
-    remoteServiceName
-  });
+  axiosInstance = wrapAxios(axiosInstance, {tracer, remoteServiceName});
 ```
 
 

packages/zipkin-instrumentation-axiosjs/test/integrationTest.js

@@ -39,7 +39,11 @@ describe('axios instrumentation - integration test', () => {
 
   beforeEach(() => {
     spans = [];
-    tracer = new Tracer({ctxImpl: new ExplicitContext(), recorder: newSpanRecorder(spans)});
+    tracer = new Tracer({
+      ctxImpl: new ExplicitContext(),
+      localServiceName: serviceName,
+      recorder: newSpanRecorder(spans)
+    });
   });
 
   function popSpan() {
@@ -52,7 +56,7 @@ describe('axios instrumentation - integration test', () => {
       timeout: 300 // this avoids flakes in CI
     });
 
-    return wrapAxios(instance, {tracer, serviceName, remoteServiceName});
+    return wrapAxios(instance, {tracer, remoteServiceName});
   }
 
   function url(path) {

packages/zipkin-instrumentation-axiosjs/test/unitTest.js

@@ -12,17 +12,17 @@ describe('axios instrumentation - unit test', () => {
     const record = sinon.spy();
     const recorder = {record};
     const ctxImpl = new ExplicitContext();
-    tracer = new Tracer({recorder, ctxImpl});
+    tracer = new Tracer({recorder, localServiceName: serviceName, ctxImpl});
   });
   it('should return an axios instance when pass axios', done => {
-    const axiosInstance = wrapAxios(axios, {tracer, serviceName, remoteServiceName});
+    const axiosInstance = wrapAxios(axios, {tracer, remoteServiceName});
     expect(axiosInstance.create).to.equal(undefined);
     done();
   });
 
   it('should return itself when pass an axiosInstance', done => {
     const axiosInstance = axios.create();
-    const zipkinAxiosInstance = wrapAxios(axiosInstance, {tracer, serviceName, remoteServiceName});
+    const zipkinAxiosInstance = wrapAxios(axiosInstance, {tracer, remoteServiceName});
     expect(axiosInstance).to.equal(zipkinAxiosInstance);
     done();
   });

packages/zipkin-instrumentation-connect/test/integrationTest.js

@@ -8,12 +8,12 @@ const middleware = require('../src/middleware');
 const https = require('https');
 const fs = require('fs');
 
-const serviceName = 'service-a';
+const serviceName = 'weather-app';
 const testSetup = () => {
   const record = sinon.spy();
   const recorder = {record};
   const ctxImpl = new ExplicitContext();
-  const tracer = new Tracer({recorder, ctxImpl});
+  const tracer = new Tracer({recorder, localServiceName: serviceName, ctxImpl});
   return {record, recorder, ctxImpl, tracer};
 };
 
@@ -23,7 +23,7 @@ describe('restify middleware - integration test', () => {
 
     ctxImpl.scoped(() => {
       const app = restify.createServer();
-      app.use(middleware({tracer, serviceName}));
+      app.use(middleware({tracer}));
       app.post('/foo', (req, res, next) => {
         ctxImpl.scoped(() => {
           // Use setTimeout to test that the trace context is propagated into the callback
@@ -58,7 +58,7 @@ describe('restify middleware - integration test', () => {
           annotations.forEach(ann => expect(ann.traceId.spanId).to.equal('bbb'));
 
           expect(annotations[0].annotation.annotationType).to.equal('ServiceName');
-          expect(annotations[0].annotation.serviceName).to.equal('service-a');
+          expect(annotations[0].annotation.serviceName).to.equal(serviceName);
 
           expect(annotations[1].annotation.annotationType).to.equal('Rpc');
           expect(annotations[1].annotation.name).to.equal('POST');
@@ -96,7 +96,7 @@ describe('restify middleware - integration test', () => {
 
     ctxImpl.scoped(() => {
       const app = restify.createServer();
-      app.use(middleware({tracer, serviceName}));
+      app.use(middleware({tracer}));
       app.post('/foo', (req, res, next) => {
         // Use setTimeout to test that the trace context is propagated into the callback
         const ctx = ctxImpl.getContext();
@@ -140,7 +140,7 @@ describe('restify middleware - integration test', () => {
 
     ctxImpl.scoped(() => {
       const app = restify.createServer();
-      app.use(middleware({tracer, serviceName}));
+      app.use(middleware({tracer}));
       app.post('/foo', (req, res, next) => {
         // Use setTimeout to test that the trace context is propagated into the callback
         const ctx = ctxImpl.getContext();
@@ -173,7 +173,7 @@ describe('restify middleware - integration test', () => {
           annotations.forEach(ann => expect(ann.traceId.spanId).to.equal('bbb'));
 
           expect(annotations[0].annotation.annotationType).to.equal('ServiceName');
-          expect(annotations[0].annotation.serviceName).to.equal('service-a');
+          expect(annotations[0].annotation.serviceName).to.equal(serviceName);
 
           expect(annotations[1].annotation.annotationType).to.equal('Rpc');
           expect(annotations[1].annotation.name).to.equal('POST');
@@ -217,7 +217,7 @@ describe('express middleware - integration test', () => {
 
     ctxImpl.scoped(() => {
       const app = express();
-      app.use(middleware({tracer, serviceName}));
+      app.use(middleware({tracer}));
       app.post('/foo', (req, res) => {
         // Use setTimeout to test that the trace context is propagated into the callback
         const ctx = ctxImpl.getContext();
@@ -246,7 +246,7 @@ describe('express middleware - integration test', () => {
           annotations.forEach(ann => expect(ann.traceId.spanId).to.equal('bbb'));
 
           expect(annotations[0].annotation.annotationType).to.equal('ServiceName');
-          expect(annotations[0].annotation.serviceName).to.equal('service-a');
+          expect(annotations[0].annotation.serviceName).to.equal(serviceName);
 
           expect(annotations[1].annotation.annotationType).to.equal('Rpc');
           expect(annotations[1].annotation.name).to.equal('POST');
@@ -284,7 +284,7 @@ describe('express middleware - integration test', () => {
 
     ctxImpl.scoped(() => {
       const app = express();
-      app.use(middleware({tracer, serviceName}));
+      app.use(middleware({tracer}));
       app.post('/foo', (req, res) => {
         // Use setTimeout to test that the trace context is propagated into the callback
         const ctx = ctxImpl.getContext();
@@ -327,7 +327,7 @@ describe('express middleware - integration test', () => {
 
     ctxImpl.scoped(() => {
       const app = express();
-      app.use(middleware({tracer, serviceName}));
+      app.use(middleware({tracer}));
       app.post('/foo', (req, res) => {
         // Use setTimeout to test that the trace context is propagated into the callback
         const ctx = ctxImpl.getContext();
@@ -355,7 +355,7 @@ describe('express middleware - integration test', () => {
           annotations.forEach(ann => expect(ann.traceId.spanId).to.equal('bbb'));
 
           expect(annotations[0].annotation.annotationType).to.equal('ServiceName');
-          expect(annotations[0].annotation.serviceName).to.equal('service-a');
+          expect(annotations[0].annotation.serviceName).to.equal(serviceName);
 
           expect(annotations[1].annotation.annotationType).to.equal('Rpc');
           expect(annotations[1].annotation.name).to.equal('POST');
@@ -399,7 +399,7 @@ describe('connect middleware - integration test', () => {
 
     ctxImpl.scoped(() => {
       const app = connect();
-      app.use(middleware({tracer, serviceName}));
+      app.use(middleware({tracer}));
       app.use('/foo', (req, res) => {
         // Use setTimeout to test that the trace context is propagated into the callback
         const ctx = ctxImpl.getContext();
@@ -432,7 +432,7 @@ describe('connect middleware - integration test', () => {
           annotations.forEach(ann => expect(ann.traceId.spanId).to.equal('bbb'));
 
           expect(annotations[0].annotation.annotationType).to.equal('ServiceName');
-          expect(annotations[0].annotation.serviceName).to.equal('service-a');
+          expect(annotations[0].annotation.serviceName).to.equal(serviceName);
 
           expect(annotations[1].annotation.annotationType).to.equal('Rpc');
           expect(annotations[1].annotation.name).to.equal('POST');
@@ -470,7 +470,7 @@ describe('connect middleware - integration test', () => {
 
     ctxImpl.scoped(() => {
       const app = connect();
-      app.use(middleware({tracer, serviceName}));
+      app.use(middleware({tracer}));
       app.use('/foo', (req, res) => {
         // Use setTimeout to test that the trace context is propagated into the callback
         const ctx = ctxImpl.getContext();
@@ -514,7 +514,7 @@ describe('connect middleware - integration test', () => {
 
     ctxImpl.scoped(() => {
       const app = connect();
-      app.use(middleware({tracer, serviceName}));
+      app.use(middleware({tracer}));
       app.use('/foo', (req, res) => {
         // Use setTimeout to test that the trace context is propagated into the callback
         const ctx = ctxImpl.getContext();
@@ -547,7 +547,7 @@ describe('connect middleware - integration test', () => {
           annotations.forEach(ann => expect(ann.traceId.spanId).to.equal('bbb'));
 
           expect(annotations[0].annotation.annotationType).to.equal('ServiceName');
-          expect(annotations[0].annotation.serviceName).to.equal('service-a');
+          expect(annotations[0].annotation.serviceName).to.equal(serviceName);
 
           expect(annotations[1].annotation.annotationType).to.equal('Rpc');
           expect(annotations[1].annotation.name).to.equal('POST');
@@ -595,7 +595,7 @@ describe('connect middleware - integration test', () => {
 
     ctxImpl.scoped(() => {
       const app = connect();
-      app.use(middleware({tracer, serviceName}));
+      app.use(middleware({tracer}));
       app.use('/foo', (req, res) => {
         // Use setTimeout to test that the trace context is propagated into the callback
         const ctx = ctxImpl.getContext();

packages/zipkin-instrumentation-cujojs-rest/test/integrationTest.js

@@ -39,7 +39,11 @@ describe('CujoJS/rest instrumentation - integration test', () => {
 
   beforeEach(() => {
     spans = [];
-    tracer = new Tracer({ctxImpl: new ExplicitContext(), recorder: newSpanRecorder(spans)});
+    tracer = new Tracer({
+      ctxImpl: new ExplicitContext(),
+      localServiceName: serviceName,
+      recorder: newSpanRecorder(spans)
+    });
   });
 
   function popSpan() {
@@ -48,7 +52,7 @@ describe('CujoJS/rest instrumentation - integration test', () => {
   }
 
   function getClient() {
-    return rest.wrap(restInterceptor, {tracer, serviceName, remoteServiceName});
+    return rest.wrap(restInterceptor, {tracer, remoteServiceName});
   }
 
   function url(path) {

packages/zipkin-instrumentation-express/README.md

@@ -31,11 +31,10 @@ const proxy = require('express-http-proxy');
 
 const ctxImpl = new ExplicitContext();
 const recorder = new ConsoleRecorder();
-const tracer = new Tracer({ctxImpl, recorder});
-const serviceName = 'weather-app';
+const tracer = new Tracer({ctxImpl, localServiceName: 'weather-app', recorder});
 const remoteServiceName = 'weather-api';
 
-const zipkinProxy = wrapExpressHttpProxy(proxy, {tracer, serviceName, remoteServiceName});
+const zipkinProxy = wrapExpressHttpProxy(proxy, {tracer, remoteServiceName});
 
 app.use('/api/weather', zipkinProxy('http://api.weather.com', {
   decorateRequest: (proxyReq, originalReq) => proxyReq.method = 'POST' // You can use express-http-proxy options as usual
@@ -50,11 +49,10 @@ const proxy = require('express-http-proxy');
 
 const ctxImpl = new CLSContext();
 const recorder = new ConsoleRecorder();
-const tracer = new Tracer({ctxImpl, recorder});
-const serviceName = 'weather-app';
+const tracer = new Tracer({ctxImpl, localServiceName: 'weather-app', recorder});
 const remoteServiceName = 'weather-api';
 
-const zipkinProxy = wrapExpressHttpProxy(proxy, {tracer, serviceName, remoteServiceName});
+const zipkinProxy = wrapExpressHttpProxy(proxy, {tracer, remoteServiceName});
 
-app.use('/api/weather', expressMiddleware({tracer, serviceName}), zipkinProxy('http://api.weather.com'));
-```
+app.use('/api/weather', expressMiddleware({tracer}), zipkinProxy('http://api.weather.com'));
+```

packages/zipkin-instrumentation-express/src/wrapExpressHttpProxy.js

@@ -7,7 +7,7 @@ function getPathnameFromPath(path) {
 }
 
 class ExpressHttpProxyInstrumentation {
-  constructor({tracer, serviceName, remoteServiceName}) {
+  constructor({tracer, serviceName = tracer.localEndpoint.serviceName, remoteServiceName}) {
     this.tracer = tracer;
     this.serviceName = serviceName;
     this.remoteServiceName = remoteServiceName;
@@ -79,11 +79,8 @@ function wrapProxy(proxy, {tracer, serviceName, remoteServiceName}) {
       };
     }
 
-    const instrumentation = new ExpressHttpProxyInstrumentation({
-      tracer,
-      serviceName,
-      remoteServiceName
-    });
+    const instrumentation =
+      new ExpressHttpProxyInstrumentation({tracer, serviceName, remoteServiceName});
 
     const wrappedOptions = options;
 

packages/zipkin-instrumentation-express/test/expressMiddlewareIntegrationTest.js

@@ -5,18 +5,17 @@ const express = require('express');
 const middleware = require('../src/expressMiddleware');
 
 describe('express middleware - integration test', () => {
+  const serviceName = 'weather-app';
+
   it('should record request & response annotations', done => {
     const record = sinon.spy();
     const recorder = {record};
     const ctxImpl = new ExplicitContext();
-    const tracer = new Tracer({recorder, ctxImpl});
+    const tracer = new Tracer({recorder, localServiceName: serviceName, ctxImpl});
 
     ctxImpl.scoped(() => {
       const app = express();
-      app.use(middleware({
-        tracer,
-        serviceName: 'service-a'
-      }));
+      app.use(middleware({tracer}));
       app.post('/foo', (req, res) => {
         // Use setTimeout to test that the trace context is propagated into the callback
         const ctx = ctxImpl.getContext();
@@ -50,7 +49,7 @@ describe('express middleware - integration test', () => {
               .to.equal(originalSpanId));
 
             expect(annotations[0].annotation.annotationType).to.equal('ServiceName');
-            expect(annotations[0].annotation.serviceName).to.equal('service-a');
+            expect(annotations[0].annotation.serviceName).to.equal(serviceName);
 
             expect(annotations[1].annotation.annotationType).to.equal('Rpc');
             expect(annotations[1].annotation.name).to.equal('POST');
@@ -93,10 +92,7 @@ describe('express middleware - integration test', () => {
 
     ctxImpl.scoped(() => {
       const app = express();
-      app.use(middleware({
-        tracer,
-        serviceName: 'service-a'
-      }));
+      app.use(middleware({tracer}));
       app.get('/foo', (req, res) => {
         // Use setTimeout to test that the trace context is propagated into the callback
         const ctx = ctxImpl.getContext();
@@ -138,11 +134,11 @@ describe('express middleware - integration test', () => {
     const record = sinon.spy();
     const recorder = {record};
     const ctxImpl = new ExplicitContext();
-    const tracer = new Tracer({recorder, ctxImpl});
+    const tracer = new Tracer({recorder, localServiceName: serviceName, ctxImpl});
 
     ctxImpl.scoped(() => {
       const app = express();
-      app.use(middleware({tracer, serviceName: 'service-a'}));
+      app.use(middleware({tracer}));
 
       app.get('/foo/:id', (req, res) => {
         // Use setTimeout to test that the trace context is propagated into the callback
@@ -185,7 +181,7 @@ describe('express middleware - integration test', () => {
     const record = sinon.spy();
     const recorder = {record};
     const ctxImpl = new ExplicitContext();
-    const tracer = new Tracer({recorder, ctxImpl});
+    const tracer = new Tracer({recorder, localServiceName: serviceName, ctxImpl});
 
     function step(num) {
       return new Promise((resolve) => {
@@ -200,10 +196,7 @@ describe('express middleware - integration test', () => {
 
     ctxImpl.scoped(() => {
       const app = express();
-      app.use(middleware({
-        tracer,
-        serviceName: 'service-a'
-      }));
+      app.use(middleware({tracer}));
 
       app.get('/foo', (req, res) => step(1)
         .then(() => step(2))
@@ -270,11 +263,11 @@ describe('express middleware - integration test', () => {
     const record = sinon.spy();
     const recorder = {record};
     const ctxImpl = new ExplicitContext();
-    const tracer = new Tracer({recorder, ctxImpl});
+    const tracer = new Tracer({recorder, localServiceName: serviceName, ctxImpl});
 
     ctxImpl.scoped(() => {
       const app = express();
-      app.use(middleware({tracer, serviceName: 'service-a'}));
+      app.use(middleware({tracer}));
 
       app.get('/error', (req, res) => {
         tracer.recordBinary('message', 'hello from within app');