fix(edges): support incoming-edge metrics

Author: dszakallas

e2e/reportApmMetrics.spec.js

@@ -23,14 +23,16 @@ test('should report apm metrics', function (t) {
     function (uri, requestBody) {
       t.pass('collector sent rpm metrics')
     })
-  serviceMocks.mockEdgeMetricsRequest(
+  serviceMocks.mockExternalEdgeMetricsRequest(
     TRACE_COLLECTOR_API_URL,
     TRACE_API_KEY_TEST,
-    TRACE_SERVICE_KEY_TEST,
-    1,
-    function (uri, requestBody) {
-      t.pass('collector sent edge metrics')
-    })
+    42,
+    Number.MAX_SAFE_INTEGER)
+  serviceMocks.mockIncomingEdgeMetricsRequest(
+    TRACE_COLLECTOR_API_URL,
+    TRACE_API_KEY_TEST,
+    42,
+    Number.MAX_SAFE_INTEGER)
   serviceMocks.mockApmMetricsRequest(
     TRACE_COLLECTOR_API_URL,
     TRACE_API_KEY_TEST,

e2e/reportHttpRequest.spec.js

@@ -28,7 +28,12 @@ test('should report http requests', function (t) {
     TRACE_API_KEY_TEST,
     DUMMY_SERVICE_KEY,
     Number.MAX_SAFE_INTEGER) // set the times parameter high so the http mock catches all
-  serviceMocks.mockEdgeMetricsRequest(
+  serviceMocks.mockExternalEdgeMetricsRequest(
+    TRACE_COLLECTOR_API_URL,
+    TRACE_API_KEY_TEST,
+    42,
+    Number.MAX_SAFE_INTEGER)
+  serviceMocks.mockIncomingEdgeMetricsRequest(
     TRACE_COLLECTOR_API_URL,
     TRACE_API_KEY_TEST,
     42,

e2e/utils/serviceMocks.js

@@ -42,13 +42,24 @@ function mockRpmMetricsRequest (url, apiKey, serviceKey, maxTimes, callback) {
     .reply(callback || 200)
 }
 
-function mockEdgeMetricsRequest (url, apiKey, serviceKey, maxTimes, callback) {
+function mockExternalEdgeMetricsRequest (url, apiKey, serviceKey, maxTimes, callback) {
   return nock(url, {
     reqheaders: {
       'Authorization': 'Bearer ' + apiKey
     }
   })
-    .post('/service/42/edge-metrics')
+    .post('/service/42/edge-external')
+    .times(maxTimes)
+    .reply(callback || 200)
+}
+
+function mockIncomingEdgeMetricsRequest (url, apiKey, serviceKey, maxTimes, callback) {
+  return nock(url, {
+    reqheaders: {
+      'Authorization': 'Bearer ' + apiKey
+    }
+  })
+    .post('/service/42/edge-incoming')
     .times(maxTimes)
     .reply(callback || 200)
 }
@@ -67,6 +78,7 @@ module.exports = {
   mockServiceKeyRequest: mockServiceKeyRequest,
   mockApmMetricsRequest: mockApmMetricsRequest,
   mockRpmMetricsRequest: mockRpmMetricsRequest,
-  mockEdgeMetricsRequest: mockEdgeMetricsRequest,
+  mockExternalEdgeMetricsRequest: mockExternalEdgeMetricsRequest,
+  mockIncomingEdgeMetricsRequest: mockIncomingEdgeMetricsRequest,
   mockHttpTransactionRequest: mockHttpTransactionRequest
 }

lib/agent/api/index.js

@@ -15,7 +15,8 @@ function CollectorApi (options) {
   this.COLLECTOR_API_SERVICE = url.resolve(options.collectorApiUrl, options.collectorApiServiceEndpoint)
   this.COLLECTOR_API_METRICS = url.resolve(options.collectorApiUrl, options.collectorApiApmMetricsEndpoint)
   this.COLLECTOR_API_RPM_METRICS = url.resolve(options.collectorApiUrl, options.collectorApiRpmMetricsEndpoint)
-  this.COLLECTOR_API_EDGE_METRICS = url.resolve(options.collectorApiUrl, options.collectorApiEdgeMetricsEndpoint)
+  this.COLLECTOR_API_INCOMING_EDGE_METRICS = url.resolve(options.collectorApiUrl, options.collectorApiIncomingEdgeMetricsEndpoint)
+  this.COLLECTOR_API_EXTERNAL_EDGE_METRICS = url.resolve(options.collectorApiUrl, options.collectorApiExternalEdgeMetricsEndpoint)
 
   this.collectorLanguage = options.collectorLanguage
   this.apiKey = options.apiKey
@@ -100,16 +101,29 @@ CollectorApi.prototype.sendApmMetrics = function (data) {
   this._send(url, this._withInstanceInfo(data))
 }
 
-CollectorApi.prototype.sendEdgeMetrics = function (data) {
+CollectorApi.prototype.sendExternalEdgeMetrics = function (data) {
   if (isNaN(this.serviceKey)) {
     debug('Service id not present, cannot send metrics')
     return
   }
 
-  var url = util.format(this.COLLECTOR_API_EDGE_METRICS, this.serviceKey)
+  var url = util.format(this.COLLECTOR_API_EXTERNAL_EDGE_METRICS, this.serviceKey)
   this._send(url, this._withInstanceInfo(data))
 }
 
+CollectorApi.prototype.sendIncomingEdgeMetrics = function (data) {
+  if (isNaN(this.serviceKey)) {
+    debug('Service id not present, cannot send metrics')
+    return
+  }
+
+  var url = util.format(this.COLLECTOR_API_INCOMING_EDGE_METRICS, this.serviceKey)
+  this._send(url, this._withInstanceInfo({
+    timestamp: (new Date()).toISOString(),
+    data: data
+  }))
+}
+
 CollectorApi.prototype.sendSamples = function (samples, sync) {
   var url = this.COLLECTOR_API_SAMPLE
   var metadata = {

lib/agent/api/index.spec.js

@@ -19,6 +19,8 @@ describe('The Trace CollectorApi module', function () {
     collectorApiApmMetricsEndpoint: '/service/%s/apm-metrics',
     collectorApiRpmMetricsEndpoint: '/service/%s/rpm-metrics',
     collectorApiEdgeMetricsEndpoint: '/service/%s/edge-metrics',
+    collectorApiIncomingEdgeMetricsEndpoint: '/service/%s/edge-incoming',
+    collectorApiExternalEdgeMetricsEndpoint: '/service/%s/edge-external',
     system: {
       hostname: 'test.org',
       processVersion: '4.3.1',
@@ -109,6 +111,44 @@ describe('The Trace CollectorApi module', function () {
     collectorApi.sendSamples(data)
   })
 
+  it('sends incomingEdgeMetrics with the required properties', function (done) {
+    var serviceKey = 12
+    var collectorApi = CollectorApi.create(defaultConfig)
+    collectorApi.serviceKey = 12
+    var data = {
+      test: 'clearly a mock'
+    }
+
+    this.sandbox.stub(Date.prototype, 'toISOString', function () {
+      return 'time'
+    })
+
+    var path = util.format(defaultConfig.collectorApiIncomingEdgeMetricsEndpoint, serviceKey)
+
+    nock(defaultConfig.collectorApiUrl, {
+      reqheaders: {
+        'Authorization': 'Bearer testApiKey',
+        'Content-Type': 'application/json',
+        'X-Reporter-Version': libPackage.version,
+        'X-Reporter-Language': defaultConfig.collectorLanguage
+      }
+    })
+      .post(path, function (body) {
+        expect(body).to.eql({
+          pid: defaultConfig.system.processId,
+          hostname: defaultConfig.system.hostname,
+          timestamp: 'time',
+          data: data
+        })
+        return true
+      })
+      .reply(201, function () {
+        done()
+      })
+
+    collectorApi.sendIncomingEdgeMetrics(data)
+  })
+
   it('can get the service key of serviceName from HttpTransaction server', function (done) {
     var collectorApi = CollectorApi.create(defaultConfig)
     var data = {

lib/agent/index.js

@@ -39,7 +39,12 @@ function Agent (options) {
     config: this.config
   })
 
-  this.edgeMetrics = Metrics.edge.create({
+  this.externalEdgeMetrics = Metrics.externalEdge.create({
+    collectorApi: this.collectorApi,
+    config: this.config
+  })
+
+  this.incomingEdgeMetrics = Metrics.incomingEdge.create({
     collectorApi: this.collectorApi,
     config: this.config
   })
@@ -78,10 +83,19 @@ Agent.prototype.getConfig = function () {
 Agent.prototype.serverReceive = function (data) {
   this.totalRequestCount++
   var spanId = data.spanId
-  var parentId = data.parentId
   var originTime = data.originTime
-
   var span = this.openSpan(data)
+  var parentId
+
+  if (!isNaN(data.parentId)) {
+    parentId = parseInt(data.parentId, 10)
+  }
+
+  this.incomingEdgeMetrics.report({
+    serviceKey: data.parentId,
+    protocol: data.protocol,
+    transportDelay: data.time - data.originTime
+  })
 
   span.events.push({
     time: data.time || microtime.now(),
@@ -182,17 +196,17 @@ Agent.prototype.clientSend = function (data) {
 Agent.prototype.clientReceive = function (data) {
   var span = this.findSpan(data.id)
 
-  this.edgeMetrics.report({
-    targetHost: data.host,
-    targetServiceKey: data.targetServiceKey,
-    protocol: data.protocol,
-    networkDelay: {
-      incoming: data.networkDelayIncoming,
-      outgoing: data.networkDelayOutgoing
-    },
-    status: data.status,
-    responseTime: data.responseTime
-  })
+  // report external edges only if service is not instrumented by Trace
+  if (typeof data.targetServiceKey === 'undefined') {
+    if (!data.statusCode || data.statusCode < 500) {
+      this.externalEdgeMetrics.report({
+        targetHost: data.host,
+        protocol: data.protocol,
+        status: data.status,
+        responseTime: data.responseTime
+      })
+    }
+  }
 
   if (!span) {
     return

lib/agent/index.spec.js

@@ -11,6 +11,7 @@ describe('The Trace agent', function () {
   var options
   var collectorApi
   var rpmMetrics
+  var incomingEdgeMetrics
   var transactionId
   var spanId
   var parentId
@@ -37,9 +38,13 @@ describe('The Trace agent', function () {
       addResponseTime: this.sandbox.spy(),
       addStatusCode: this.sandbox.spy()
     }
+    incomingEdgeMetrics = {
+      report: this.sandbox.spy()
+    }
     this.sandbox.stub(CollectorApi, 'create').returns(collectorApi)
     this.sandbox.stub(Metrics.apm, 'create')
     this.sandbox.stub(Metrics.rpm, 'create').returns(rpmMetrics)
+    this.sandbox.stub(Metrics.incomingEdge, 'create').returns(incomingEdgeMetrics)
     this.sandbox.stub(microtime, 'now').returns(time)
     options = {
       config: {
@@ -51,15 +56,25 @@ describe('The Trace agent', function () {
   })
 
   it('does server receive', function () {
+    var originTime = time - 1000
+
     agent.serverReceive({
       id: transactionId,
       spanId: spanId,
       parentId: parentId,
       url: url,
       host: host,
-      method: 'GET'
+      method: 'GET',
+      originTime: originTime,
+      protocol: 'http',
+      time: time
     })
 
+    expect(incomingEdgeMetrics.report).to.have.been.calledWith({
+      transportDelay: time - originTime,
+      serviceKey: parentId,
+      protocol: 'http'
+    })
     expect(agent.totalRequestCount).to.eql(1)
     expect(agent.partials[transactionId]).to.eql({
       requestId: transactionId,
@@ -73,6 +88,40 @@ describe('The Trace agent', function () {
           endpoint: url,
           method: 'GET',
           parent: 0,
+          originTime: originTime
+        }
+      }]
+    })
+  })
+
+  it('does server receive when there is no parentId', function () {
+    agent.serverReceive({
+      id: transactionId,
+      spanId: spanId,
+      url: url,
+      host: host,
+      method: 'GET',
+      protocol: 'http'
+    })
+
+    expect(incomingEdgeMetrics.report).to.have.been.calledWith({
+      protocol: 'http',
+      serviceKey: undefined,
+      transportDelay: NaN
+    })
+    expect(agent.totalRequestCount).to.eql(1)
+    expect(agent.partials[transactionId]).to.eql({
+      requestId: transactionId,
+      isSampled: false,
+      isForceSampled: false,
+      events: [{
+        type: 'sr',
+        time: time,
+        data: {
+          rpcId: spanId,
+          endpoint: url,
+          method: 'GET',
+          parent: undefined,
           originTime: undefined
         }
       }]