newrelic 4.5.0 → 4.8.0

package/lib/instrumentation/mongodb.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const semver = require('semver')
+
 // XXX: When this instrumentation is modularized, update this thread
 // with a cautionary note:
 // https://discuss.newrelic.com/t/feature-idea-using-mongoose-cursors-memory-leaking-very-quickly/49270/14
@@ -9,7 +11,7 @@
 // location.
 
 // legacy endpoint enumerations
-var DB_OPS = [
+const DB_OPS = [
   'addUser',
   'authenticate',
   'collection',
@@ -37,7 +39,7 @@ var DB_OPS = [
   '_executeQueryCommand'
 ]
 
-var COLLECTION_OPS = [
+const COLLECTION_OPS = [
   'aggregate',
   'bulkWrite',
   'count',
@@ -79,13 +81,13 @@ var COLLECTION_OPS = [
   'updateOne'
 ]
 
-var GRID_OPS = [
+const GRID_OPS = [
   'put',
   'get',
   'delete'
 ]
 
-var CURSOR_OPS = [
+const CURSOR_OPS = [
   'nextObject',
   'next',
   'toArray',
@@ -97,24 +99,10 @@ module.exports = initialize
 
 function initialize(agent, mongodb, moduleName, shim) {
   if (!mongodb) return
-  var recordDesc = {
-    'Gridstore': {isQuery: false, makeDesc: function makeGridDesc(opName) {
-      return {name:'GridFS-' + opName, callback: shim.LAST}
-    }},
-    'OrderedBulkOperation': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'UnorderedBulkOperation': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'CommandCursor': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'AggregationCursor': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'Cursor': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'Collection': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'Db': {isQuery: false, makeDesc: function makeDbDesc() {
-      return {callback: shim.LAST}
-    }}
-  }
 
   shim.setDatastore(shim.MONGODB)
   shim.setParser(function mongoQueryParser(operation) {
-    var collection = this.collectionName || 'unknown'
+    let collection = this.collectionName || 'unknown'
     if (this.collection && this.collection.collectionName) {
       collection = this.collection.collectionName
     } else if (this.s && this.s.name) {
@@ -123,36 +111,51 @@ function initialize(agent, mongodb, moduleName, shim) {
       collection = this.ns.split(/\./)[1] || collection
     }
 
-    return {
-      operation: operation,
-      collection: collection
-    }
+    return {operation, collection}
   })
 
-  // instrument using the apm api
-  if (mongodb.instrument) {
-    var instrumenter = mongodb.instrument(Object.create(null), instrumentModules)
-    instrumenter.on('started', function onMongoEventStarted(evnt) {
-      // This assumes that this `started` event is fired _after_ our wrapper
-      // starts and creates the segment. We perform a check of the segment name
-      // out of an excess of caution.
-      var connId = evnt.connectionId
-      if (connId) {
-        // Mongo sticks the path to the domain socket in the "host" slot, but we
-        // want it in the "port", so if we have a domain socket we need to change
-        // the order of our parameters.
-        if (connId.domainSocket) {
-          shim.captureInstanceAttributes('localhost', connId.host, evnt.databaseName)
-        } else {
-          shim.captureInstanceAttributes(connId.host, connId.port, evnt.databaseName)
-        }
-      }
-    })
+  const mongoVersion = shim.require('./package.json').version
+  if (semver.satisfies(mongoVersion, '>=3.0.6') && mongodb.instrument) {
+    instrument306(shim, mongodb)
+  } else if (mongodb.instrument) {
+    instrumentInstrument(shim, mongodb)
   } else {
-    // fallback to legacy enumerations
-    legacyInstrumentation()
+    instrumentLegacy(shim, mongodb)
+  }
+}
+
+function instrument306(shim, mongodb) {
+  const instrumenter = mongodb.instrument(Object.create(null), () => {})
+  captureAttributesOnStarted(shim, instrumenter)
+  instrumentLegacy(shim, mongodb)
+
+  if (shim.isFunction(instrumenter.uninstrument)) {
+    shim.agent.once('unload', function uninstrumentMongo() {
+      instrumenter.uninstrument()
+    })
+  }
+}
+
+function instrumentInstrument(shim, mongodb) {
+  const recordDesc = {
+    'Gridstore': {isQuery: false, makeDesc: function makeGridDesc(opName) {
+      return {name:'GridFS-' + opName, callback: shim.LAST}
+    }},
+    'OrderedBulkOperation': {isQuery: true, makeDesc: makeQueryDescFunc},
+    'UnorderedBulkOperation': {isQuery: true, makeDesc: makeQueryDescFunc},
+    'CommandCursor': {isQuery: true, makeDesc: makeQueryDescFunc},
+    'AggregationCursor': {isQuery: true, makeDesc: makeQueryDescFunc},
+    'Cursor': {isQuery: true, makeDesc: makeQueryDescFunc},
+    'Collection': {isQuery: true, makeDesc: makeQueryDescFunc},
+    'Db': {isQuery: false, makeDesc: function makeDbDesc() {
+      return {callback: shim.LAST}
+    }}
   }
 
+  // instrument using the apm api
+  const instrumenter = mongodb.instrument(Object.create(null), instrumentModules)
+  captureAttributesOnStarted(shim, instrumenter)
+
   function instrumentModules(err, instrumentations) {
     if (err) {
       shim.logger
@@ -182,9 +185,9 @@ function initialize(agent, mongodb, moduleName, shim) {
         var makeDescFunc = recordDesc[objectName].makeDesc
         var proto = object.prototype
         if (isQuery) {
-          shim.recordQuery(proto, method, makeDescFunc(method))
+          shim.recordQuery(proto, method, makeDescFunc(shim, method))
         } else if (isQuery === false) { // could be unset
-          shim.recordOperation(proto, method, makeDescFunc(method))
+          shim.recordOperation(proto, method, makeDescFunc(shim, method))
         } else {
           shim.logger.trace('No wrapping method found for %s', objectName)
         }
@@ -197,95 +200,135 @@ function initialize(agent, mongodb, moduleName, shim) {
       shim.recordOperation(object.prototype, 'pipe')
     }
   }
+}
 
-  function makeQueryDescFunc(methodName) {
-    return function queryDescFunc() {
-      var parameters = getInstanceAttributeParameters(this)
-      var callback = shim.LAST
-      if (methodName === 'each') {
-        return {query: methodName, parameters: parameters, rowCallback: callback}
+function captureAttributesOnStarted(shim, instrumenter) {
+  instrumenter.on('started', function onMongoEventStarted(evnt) {
+    // This assumes that this `started` event is fired _after_ our wrapper
+    // starts and creates the segment. We perform a check of the segment name
+    // out of an excess of caution.
+    const connId = evnt.connectionId
+    if (connId) {
+      // Mongo sticks the path to the domain socket in the "host" slot, but we
+      // want it in the "port", so if we have a domain socket we need to change
+      // the order of our parameters.
+      if (typeof connId === 'string') {
+        const parts = connId.split(':')
+        if (parts.length && parts[0][0] === '/') {
+          shim.captureInstanceAttributes('localhost', parts[0], evnt.databaseName)
+        } else {
+          shim.captureInstanceAttributes(parts[0], parts[1], evnt.databaseName)
+        }
+      } else if (connId.domainSocket) {
+        shim.captureInstanceAttributes('localhost', connId.host, evnt.databaseName)
+      } else {
+        shim.captureInstanceAttributes(connId.host, connId.port, evnt.databaseName)
       }
-
-      // segment name does not actually use query string
-      // method name is set as query so the query parser has access to the op name
-      return {query: methodName, callback: callback, parameters: parameters}
     }
-  }
+  })
+}
 
-  function getInstanceAttributeParameters(obj) {
-    if (obj.db && obj.db.serverConfig) {
-      shim.logger.trace('Adding datastore instance attributes from obj.db.serverConfig')
-      var serverConfig = obj.db.serverConfig
-      var db = serverConfig.db || serverConfig.dbInstance
-      return doCapture(serverConfig, db && db.databaseName)
-    } else if (obj.s && obj.s.db && obj.s.topology) {
-      shim.logger.trace(
-        'Adding datastore instance attributes from obj.s.db + obj.s.topology'
+function instrumentLegacy(shim, mongodb) {
+  instrumentCursor(mongodb.Cursor)
+  instrumentCursor(shim.require('./lib/aggregation_cursor'))
+  instrumentCursor(shim.require('./lib/command_cursor'))
+
+  if (mongodb.Collection && mongodb.Collection.prototype) {
+    const proto = mongodb.Collection.prototype
+    for (let i = 0; i < COLLECTION_OPS.length; i++) {
+      shim.recordQuery(
+        proto,
+        COLLECTION_OPS[i],
+        makeQueryDescFunc(shim, COLLECTION_OPS[i])
       )
-      var databaseName = obj.s.db.databaseName || null
-      var topology = obj.s.topology
-      if (topology.s && topology.s.options) {
-        return doCapture(topology.s.options, databaseName)
-      }
     }
+  }
 
-    shim.logger.trace('Could not find datastore instance attributes.')
-    return {
-      host: null,
-      port_path_or_id: null,
-      database_name: null
+  if (mongodb.Grid && mongodb.Grid.prototype) {
+    const proto = mongodb.Grid.prototype
+    for (let i = 0; i < CURSOR_OPS.length; i++) {
+      shim.recordOperation(proto, GRID_OPS[i],
+        {name:'GridFS-' + GRID_OPS[i], callback: shim.LAST})
     }
+  }
 
-    function doCapture(conf, database) {
-      var host = conf.host
-      var port = conf.port
-
-      // If using a domain socket, mongo stores the path as the host name, but we
-      // pass it through the port value.
-      if (
-        (conf.socketOptions && conf.socketOptions.domainSocket) || /\.sock$/.test(host)
-      ) {
-        port = host
-        host = 'localhost'
-      }
+  if (mongodb.Db && mongodb.Db.prototype) {
+    const proto = mongodb.Db.prototype
+    shim.recordOperation(proto, DB_OPS, {callback: shim.LAST})
+    shim.recordOperation(mongodb.Db, 'connect', {callback: shim.LAST})
+  }
 
-      return {
-        host: host,
-        port_path_or_id: port,
-        database_name: database
+  function instrumentCursor(Cursor) {
+    if (Cursor && Cursor.prototype) {
+      const proto = Cursor.prototype
+      for (let i = 0; i < CURSOR_OPS.length; i++) {
+        shim.recordQuery(proto, CURSOR_OPS[i], makeQueryDescFunc(shim, CURSOR_OPS[i]))
       }
+
+      shim.recordQuery(proto, 'each', makeQueryDescFunc(shim, 'each'))
+      shim.recordOperation(proto, 'pipe')
     }
   }
+}
 
-  function legacyInstrumentation() {
-    if (mongodb.Cursor && mongodb.Cursor.prototype) {
-      var proto = mongodb.Cursor.prototype
-      for (var i = 0; i < CURSOR_OPS.length; i++) {
-        shim.recordQuery(proto, CURSOR_OPS[i], makeQueryDescFunc(CURSOR_OPS[i]))
-      }
-
-      shim.recordQuery(proto, 'each', makeQueryDescFunc('each'))
+function makeQueryDescFunc(shim, methodName) {
+  if (methodName === 'each') {
+    return function eachDescFunc() {
+      const parameters = getInstanceAttributeParameters(shim, this)
+      return {query: methodName, parameters, rowCallback: shim.LAST}
     }
+  }
 
-    if (mongodb.Collection && mongodb.Collection.prototype) {
-      var proto = mongodb.Collection.prototype
-      for (var i = 0; i < COLLECTION_OPS.length; i++) {
-        shim.recordQuery(proto, COLLECTION_OPS[i], makeQueryDescFunc(COLLECTION_OPS[i]))
-      }
+  return function queryDescFunc() {
+    // segment name does not actually use query string
+    // method name is set as query so the query parser has access to the op name
+    const parameters = getInstanceAttributeParameters(shim, this)
+    return {query: methodName, parameters, callback: shim.LAST}
+  }
+}
+
+function getInstanceAttributeParameters(shim, obj) {
+  if (obj.db && obj.db.serverConfig) {
+    shim.logger.trace('Adding datastore instance attributes from obj.db.serverConfig')
+    const serverConfig = obj.db.serverConfig
+    const db = serverConfig.db || serverConfig.dbInstance
+    return doCapture(serverConfig, db && db.databaseName)
+  } else if (obj.s && obj.s.db && obj.s.topology) {
+    shim.logger.trace(
+      'Adding datastore instance attributes from obj.s.db + obj.s.topology'
+    )
+    const databaseName = obj.s.db.databaseName || null
+    const topology = obj.s.topology
+    if (topology.s && topology.s.options) {
+      return doCapture(topology.s.options, databaseName)
     }
+  }
 
-    if (mongodb.Grid && mongodb.Grid.prototype) {
-      var proto = mongodb.Grid.prototype
-      for (var i = 0; i < CURSOR_OPS.length; i++) {
-        shim.recordOperation(proto, GRID_OPS[i],
-          {name:'GridFS-' + GRID_OPS[i], callback: shim.LAST})
-      }
+  shim.logger.trace('Could not find datastore instance attributes.')
+  return {
+    host: null,
+    port_path_or_id: null,
+    database_name: null
+  }
+
+  function doCapture(conf, database) {
+    let host = conf.host
+    let port = conf.port
+
+    // If using a domain socket, mongo stores the path as the host name, but we
+    // pass it through the port value.
+    if (
+      (conf.socketOptions && conf.socketOptions.domainSocket) ||
+      /\.sock$/.test(host)
+    ) {
+      port = host
+      host = 'localhost'
     }
 
-    if (mongodb.Db && mongodb.Db.prototype) {
-      var proto = mongodb.Db.prototype
-      shim.recordOperation(proto, DB_OPS, {callback: shim.LAST})
-      shim.recordOperation(mongodb.Db, 'connect', {callback: shim.LAST})
+    return {
+      host: host,
+      port_path_or_id: port,
+      database_name: database
     }
   }
 }

package/lib/metrics/recorders/http.js

@@ -33,7 +33,7 @@ function recordWeb(segment, scope) {
     tx.measure(NAMES.QUEUETIME, null, tx.queueTime)
   }
 
-  if (config.feature_flag.distributed_tracing) {
+  if (config.distributed_tracing.enabled) {
     recordDistributedTrace(tx, 'Web', duration, exclusive)
   } else if (tx.incomingCatId) {
     tx.measure(

package/lib/metrics/recorders/other.js

@@ -34,7 +34,7 @@ function recordBackground(segment, scope) {
   )
   tx.measure(NAMES.OTHER_TRANSACTION.TOTAL_TIME, null, totalTime, exclusive)
 
-  if (tx.agent.config.feature_flag.distributed_tracing) {
+  if (tx.agent.config.distributed_tracing.enabled) {
     recordDistributedTrace(tx, 'Other', duration, exclusive)
   }
 }

package/lib/priority-queue.js

@@ -3,7 +3,7 @@
 var Heap = require('@tyriar/fibonacci-heap').FibonacciHeap
 
 function PriorityQueue(limit) {
-  this.limit = limit || 10
+  this.limit = limit == null ? 10 : limit
   this.seen = 0
   this._data = new Heap()
 
@@ -24,8 +24,11 @@ PriorityQueue.prototype.getMinimumPriority = function getMinimumPriority() {
 }
 
 PriorityQueue.prototype.add = function add(value, priority) {
-  priority = priority || Math.random()
   this.seen++
+  if (this.limit <= 0) {
+    return false
+  }
+  priority = priority || Math.random()
   if (this.length === this.limit) {
     return this._replace(value, priority)
   }

package/lib/shim/message-shim.js

@@ -333,10 +333,6 @@ function recordProduce(nodule, properties, recordNamer) {
     }
 
     var name = _nameMessageSegment(shim, msgDesc, shim._metrics.PRODUCE)
-    if (msgDesc.headers) {
-      shim.insertCATRequestHeaders(msgDesc.headers, true)
-    }
-
     if (!shim.agent.config.message_tracer.segment_parameters.enabled) {
       delete msgDesc.parameters
     } else if (msgDesc.routingKey) {
@@ -350,6 +346,11 @@ function recordProduce(nodule, properties, recordNamer) {
       promise: msgDesc.promise || false,
       callback: msgDesc.callback || null,
       recorder: genericRecorder,
+      inContext: function generateCATHeaders() {
+        if (msgDesc.headers) {
+          shim.insertCATRequestHeaders(msgDesc.headers, true)
+        }
+      },
       parameters: msgDesc.parameters || null
     }
   })

package/lib/shim/shim.js

@@ -946,7 +946,7 @@ function record(nodule, properties, recordNamer) {
       var promised = false
       var ret
       try {
-        ret = shim.applySegment(fn, segment, true, ctx, args)
+        ret = shim.applySegment(fn, segment, true, ctx, args, segDesc.inContext)
         if (segDesc.after && segDesc.promise && shim.isPromise(ret)) {
           promised = true
           return ret.then(function onThen(val) {
@@ -1286,7 +1286,7 @@ function storeSegment(obj, segment) {
  * Sets the given segment as the active one for the duration of the function's
  * execution.
  *
- * - `applySegment(func, segment, full, context, args)`
+ * - `applySegment(func, segment, full, context, args[, inContextCB])`
  *
  * @memberof Shim.prototype
  *
@@ -1305,9 +1305,15 @@ function storeSegment(obj, segment) {
  * @param {Array.<*>} args
  *  The arguments to be passed into the function.
  *
+ * @param {Function} [inContextCB]
+ *  The function used to do more instrumentation work. This function is
+ *  guaranteed to be executed with the segment associated with.
+ *
+ *
  * @return {*} Whatever value `func` returned.
  */
-function applySegment(func, segment, full, context, args) {
+/* eslint-disable max-params */
+function applySegment(func, segment, full, context, args, inContextCB) {
   // Exist fast for bad arguments.
   if (!this.isFunction(func)) {
     return
@@ -1327,6 +1333,10 @@ function applySegment(func, segment, full, context, args) {
     segment.start()
   }
 
+  if (typeof inContextCB === 'function') {
+    inContextCB()
+  }
+
   // Execute the function and then return the tracer segment to the old one.
   try {
     return func.apply(context, args)
@@ -1337,6 +1347,7 @@ function applySegment(func, segment, full, context, args) {
     tracer.segment = prevSegment
   }
 }
+/* eslint-enable max-params */
 
 /**
  * Creates a new segment.

package/lib/shim/specs/index.js

@@ -45,6 +45,7 @@ function WrapSpec(spec) {
 function SegmentSpec(spec) {
   this.name       = hasOwnProperty(spec, 'name') ? spec.name : null
   this.recorder   = hasOwnProperty(spec, 'recorder') ? spec.recorder : null
+  this.inContext  = hasOwnProperty(spec, 'inContext') ? spec.inContext : null
   this.parent     = hasOwnProperty(spec, 'parent') ? spec.parent : null
   this.parameters = hasOwnProperty(spec, 'parameters') ? spec.parameters : null
   this.internal   = hasOwnProperty(spec, 'internal') ? spec.internal : false

package/lib/shim/transaction-shim.js

@@ -287,7 +287,7 @@ function handleCATHeaders(headers, segment, transportType) {
     transportType = Transaction.TRANSPORT_TYPES.UNKNOWN
   }
 
-  if (this.agent.config.feature_flag.distributed_tracing) {
+  if (this.agent.config.distributed_tracing.enabled) {
     const payload = headers[DISTRIBUTED_TRACE_HEADER]
     if (payload) {
       tx.acceptDistributedTracePayload(payload, transportType)
@@ -351,7 +351,7 @@ function insertCATRequestHeaders(headers, useAlternateHeaderNames) {
     this.logger.trace('CAT disabled, not adding headers.')
     return
   }
-  var usingDistributedTracing = this.agent.config.feature_flag.distributed_tracing
+  var usingDistributedTracing = this.agent.config.distributed_tracing.enabled
   if (!this.agent.config.encoding_key && !usingDistributedTracing) {
     this.logger.warn('Missing encoding key, not adding CAT headers!')
     return
@@ -433,7 +433,7 @@ function insertCATReplyHeader(headers, useAlternateHeaderNames) {
   if (!config.cross_application_tracer.enabled) {
     this.logger.trace('CAT disabled, not adding reply header.')
     return
-  } else if (config.feature_flag.distributed_tracing) {
+  } else if (config.distributed_tracing.enabled) {
     this.logger.warn('CAT disabled, distributed tracing is enabled')
     return
   } else if (!config.encoding_key) {

package/lib/shimmer.js

@@ -205,6 +205,9 @@ var shimmer = module.exports = {
       if (original.__NR_unwrap) return logger.debug("%s already wrapped by agent.", fqmn)
 
       var wrapped = wrapper(original, method)
+      Object.keys(original).forEach((key) => {
+        wrapped[key] = original[key]
+      })
       wrapped.__NR_original = original
       wrapped.__NR_unwrap = function __NR_unwrap() {
         nodule[method] = original

package/lib/transaction/dt-payload.js

@@ -7,6 +7,12 @@ const DT_VERSION_MAJOR = 0
 const DT_VERSION_MINOR = 1
 
 module.exports = class DistributedTracePayload {
+  /**
+   * The class reponsible for producing distributed trace payloads.
+   * Created by calling {@link TransactionHandle#createDistributedTracePayload}.
+   *
+   * @constructor
+   */
   constructor(payload) {
     logger.trace('DistributedTracePayload created with %s', payload)
     this.plainTextPayload = JSON.stringify({
@@ -16,11 +22,21 @@ module.exports = class DistributedTracePayload {
     this.base64Payload = null
   }
 
+  /**
+   * @returns {String} The base64 encoded JSON representation of the
+   * distributed trace payload.
+   */
   text() {
     logger.trace('DistributedTracePayload text: %s', this.plainTextPayload)
     return this.plainTextPayload
   }
 
+  /**
+   * Construct a payload suitable for HTTP transport.
+   *
+   * @returns {String} The base64 encoded JSON representation of the
+   * distributed trace payload.
+   */
   httpSafe() {
     if (!this.base64Payload) {
       this.base64Payload = makeBuffer(this.plainTextPayload, 'utf-8').toString('base64')

package/lib/transaction/handle.js

@@ -33,7 +33,7 @@ module.exports = class TransactionHandle {
   *
   * Proxy method for Transaction#createDistrubtedTracePayload.
   *
-  * @returns {DistributedTracePayload} The created payload.
+  * @returns {DistributedTracePayload} The created payload object.
   *
   */
   createDistributedTracePayload() {

package/lib/transaction/index.js

@@ -193,6 +193,10 @@ Transaction.prototype.end = function end(done) {
       transaction.record()
     }
 
+    // This is function currently must be called after all recorders have been fired due
+    // to some of the recorders (namely the db recorders) add parameters to the segments.
+    transaction.trace.generateSpanEvents()
+
     transaction.agent.emit('transactionFinished', transaction)
     if (typeof done === 'function') {
       done(transaction)
@@ -688,7 +692,7 @@ Transaction.prototype.getIntrinsicAttributes = function getIntrinsicAttributes()
 
     // If CAT is enabled, extract the path hashes and referring transaction info.
     if (config.cross_application_tracer.enabled) {
-      if (config.feature_flag.distributed_tracing) {
+      if (config.distributed_tracing.enabled) {
         this.addDistributedTraceIntrinsics(this._intrinsicAttributes)
       } else {
         this._intrinsicAttributes.path_hash = hashes.calculatePathHash(
@@ -750,7 +754,7 @@ function acceptDistributedTracePayload(payload, transport) {
   }
 
   const config = this.agent.config
-  const distTraceEnabled = config.feature_flag.distributed_tracing
+  const distTraceEnabled = config.distributed_tracing.enabled
   const catEnabled = config.cross_application_tracer.enabled
   const trustedAccount = config.trusted_account_key || config.account_id
 
@@ -895,7 +899,7 @@ function createDistributedTracePayload() {
   const config = this.agent.config
   const accountId = config.account_id
   const appId = config.application_id
-  const distTraceEnabled = config.feature_flag.distributed_tracing
+  const distTraceEnabled = config.distributed_tracing.enabled
   const catEnabled = config.cross_application_tracer.enabled
 
   if (!accountId || !appId || !distTraceEnabled || !catEnabled) {
@@ -920,7 +924,7 @@ function createDistributedTracePayload() {
     ti: Date.now()
   }
 
-  if (this.agent.config.span_events.enabled && currSegment) {
+  if (this.agent.config.span_events.enabled && this.sampled && currSegment) {
     data.id = currSegment.id
   }