newrelic 5.13.0 → 6.2.0

package/lib/config/env.js

@@ -51,6 +51,11 @@ const ENV_MAPPING = {
       include: 'NEW_RELIC_TRANSACTION_EVENTS_ATTRIBUTES_INCLUDE'
     }
   },
+  diagnostics: {
+    code_injector: {
+      enabled: 'NEW_RELIC_DIAGNOSTICS_CODE_INJECTOR_ENABLED'
+    }
+  },
   transaction_tracer: {
     attributes: {
       enabled: 'NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_ENABLED',
@@ -139,6 +144,11 @@ const ENV_MAPPING = {
   serverless_mode: {
     enabled: 'NEW_RELIC_SERVERLESS_MODE_ENABLED'
   },
+  plugins: {
+    native_metrics: {
+      enabled: 'NEW_RELIC_NATIVE_METRICS_ENABLED'
+    }
+  },
   trusted_account_key: 'NEW_RELIC_TRUSTED_ACCOUNT_KEY',
   primary_application_id: 'NEW_RELIC_PRIMARY_APPLICATION_ID',
   account_id: 'NEW_RELIC_ACCOUNT_ID'
@@ -169,6 +179,11 @@ const LIST_VARS = new Set([
   'NEW_RELIC_AUDIT_LOG_ENDPOINTS'
 ])
 
+// Mapping to customize the split delimiter for the LIST_VARS
+const LIST_VARS_CUSTOM_DELIMITERS = {
+  'NEW_RELIC_APP_NAME': /;|,/
+}
+
 // Values in object lists are comma-delimited object literals
 const OBJECT_LIST_VARS = new Set([
   'NEW_RELIC_NAMING_RULES'
@@ -186,6 +201,7 @@ const BOOLEAN_VARS = new Set([
   'NEW_RELIC_TRACER_ENABLED',
   'NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_ENABLED',
   'NEW_RELIC_TRANSACTION_EVENTS_ATTRIBUTES_ENABLED',
+  'NEW_RELIC_DIAGNOSTICS_CODE_INJECTOR_ENABLED',
   'NEW_RELIC_TRANSACTION_SEGMENTS_ATTRIBUTES_ENABLED',
   'NEW_RELIC_DEBUG_METRICS',
   'NEW_RELIC_DEBUG_TRACER',
@@ -210,7 +226,8 @@ const BOOLEAN_VARS = new Set([
   'NEW_RELIC_UTILIZATION_DETECT_DOCKER',
   'NEW_RELIC_UTILIZATION_DETECT_GCP',
   'NEW_RELIC_UTILIZATION_DETECT_KUBERNETES',
-  'NEW_RELIC_SERVERLESS_MODE_ENABLED'
+  'NEW_RELIC_SERVERLESS_MODE_ENABLED',
+  'NEW_RELIC_NATIVE_METRICS_ENABLED'
 ])
 
 const FLOAT_VARS = new Set([
@@ -225,6 +242,7 @@ const INT_VARS = new Set([
 
 exports.ENV_MAPPING = ENV_MAPPING
 exports.LIST_VARS = LIST_VARS
+exports.LIST_VARS_CUSTOM_DELIMITERS = LIST_VARS_CUSTOM_DELIMITERS
 exports.OBJECT_LIST_VARS = OBJECT_LIST_VARS
 exports.BOOLEAN_VARS = BOOLEAN_VARS
 exports.FLOAT_VARS = FLOAT_VARS

package/lib/config/index.js

@@ -135,12 +135,11 @@ function Config(config) {
   this.sampling_target_period_in_seconds = 60
   this.max_payload_size_in_bytes = DEFAULT_MAX_PAYLOAD_SIZE_IN_BYTES
 
-  // how frequently harvester runs
-  this.data_report_period = 60
-
   // this value is arbitrary
   this.max_trace_segments = 900
 
+  this.entity_guid = null
+
   // feature level of this account
   this.product_level = 0
   // product-level related
@@ -182,7 +181,7 @@ function Config(config) {
     this.event_harvest_config = {
       report_period_ms: 60000,
       harvest_limits: {
-        analytic_event_data: this.transaction_events.max_samples_per_minute,
+        analytic_event_data: this.transaction_events.max_samples_stored,
         custom_event_data: this.custom_insights_events.max_samples_stored,
         error_event_data: this.error_collector.max_event_samples_stored,
         span_event_data: SPAN_EVENT_LIMIT
@@ -338,7 +337,6 @@ Config.prototype._fromServer = function _fromServer(params, key) {
 
     case 'apdex_t':
     case 'web_transactions_apdex':
-    case 'data_report_period':
       this._updateIfChanged(params, key)
       break
     case 'event_harvest_config':
@@ -551,6 +549,11 @@ Config.prototype._fromServer = function _fromServer(params, key) {
       )
       break
 
+    // Entity GUID
+    case 'entity_guid':
+      this.entity_guid = params[key]
+      break
+
     // These settings aren't supported by the agent (yet).
     case 'sampling_rate':
     case 'episodes_file':
@@ -578,7 +581,6 @@ Config.prototype._fromServer = function _fromServer(params, key) {
     case 'transaction_events.attributes.exclude':
     case 'transaction_events.attributes.include':
     case 'transaction_events.max_samples_stored':
-    case 'transaction_events.max_samples_per_minute':
     case 'transaction_tracer.attributes.enabled':
     case 'transaction_tracer.attributes.exclude':
     case 'transaction_tracer.attributes.include':
@@ -1029,7 +1031,7 @@ Config.prototype._fromPassed = function _fromPassed(external, internal, arbitrar
       return
     }
 
-    if (typeof node === 'object' && !Array.isArray(node)) {
+    if (typeof node === 'object' && !(node instanceof RegExp) && !Array.isArray(node)) {
       // is top level and can have arbitrary keys
       var allowArbitrary = internal === this || HAS_ARBITRARY_KEYS.has(key)
       this._fromPassed(node, internal[key], allowArbitrary)
@@ -1104,7 +1106,8 @@ Config.prototype._fromEnvironment = function _fromEnvironment(metadata, data) {
       var setting = process.env[node]
       if (setting) {
         if (ENV.LIST_VARS.has(node)) {
-          data[value] = setting.split(',').map(function trimVal(k) {
+          let split = ENV.LIST_VARS_CUSTOM_DELIMITERS[node] || /,/
+          data[value] = setting.split(split).map(function trimVal(k) {
             return k.trim()
           })
         } else if (ENV.OBJECT_LIST_VARS.has(node)) {
@@ -1146,6 +1149,25 @@ Config.prototype._loggingManuallySet = function _loggingManuallySet(inputConfig)
   return (inputEnabled !== undefined) || (envEnabled !== undefined)
 }
 
+/**
+ * Returns true if native-metrics has been manually enabled via configuration
+ * file or enveironment variable
+ * 
+ * @param {*} inputConfig configuration pass to the Config constructor
+ * 
+ * @returns {boolean}
+ */
+Config.prototype._nativeMetricsManuallySet = 
+  function _nativeMetricsManuallySet(inputConfig) {
+    const inputEnabled = inputConfig 
+      && inputConfig.plugins 
+      && inputConfig.plugins.native_metrics
+      && inputConfig.plugins.native_metrics.enabled
+    const envEnabled = process.env.NEW_RELIC_NATIVE_METRICS_ENABLED
+
+    return (inputEnabled !== undefined) || (envEnabled !== undefined)
+  }
+
 /**
  * Returns true if distributed tracing has been manually enabled via configuration file or
  * environment variable.
@@ -1189,6 +1211,24 @@ Config.prototype._enforceServerless = function _enforceServerless(inputConfig) {
       )
     }
 
+    if (this._nativeMetricsManuallySet(inputConfig) && 
+      this.plugins.native_metrics.enabled) {
+      logger.info(
+        'Enabling the native-metrics module when in serverless mode may greatly ' +
+        'increase cold-start times. Given the limited benefit of the VM metrics' +
+        'and general lack of control in a serverless environment, we do not ' +
+        'recommend this trade-off.'
+      )
+    } else {
+      this.plugins.native_metrics.enabled = false
+
+      logger.info(
+        'The native-metrics module is disabled by default when serverless_mode ' +
+        'is enabled.  If desired, enable the native-metrics module via config file ' +
+        'or environment variable.'
+      )
+    }
+
     if (!this._DTManuallySet(inputConfig)) {
       this.distributed_tracing.enabled = true
     }
@@ -1207,6 +1247,10 @@ Config.prototype._enforceServerless = function _enforceServerless(inputConfig) {
     }
     // default trusted_account_key to account_id
     this.trusted_account_key = this.trusted_account_key || this.account_id
+
+    // Not required in serverless mode but must default to Unknown to function.
+    this.primary_application_id = this.primary_application_id || 'Unknown'
+
     return
   }
   const DT_KEYS = ['account_id', 'primary_application_id', 'trusted_account_key']

package/lib/injector.js

@@ -0,0 +1,161 @@
+'use strict'
+
+// to avoid parsing the esprima code base we require it here
+// TODO: excise this with better internal file filtering
+const esprima = require('esprima')
+const ecg = require('escodegen')
+const fileNameToken = {
+  type: 'Literal',
+  value: null
+}
+const lineNumberTokenTemplate = {
+  type: 'Literal',
+  value: null
+}
+
+class Mutator {
+  constructor(appliesTo, mutate) {
+    this.appliesTo = appliesTo
+    this.mutate = mutate
+    this.tokens = []
+  }
+
+  add(token) {
+    this.tokens.push(token)
+  }
+
+  apply() {
+    this.tokens.forEach(this.mutate)
+  }
+}
+
+const functionTypes = new Set([
+  'ArrowFunctionExpression',
+  'FunctionExpression',
+  'AsyncFunction'
+])
+
+const equalityCheckOps = new Set([
+  '==',
+  '===',
+  '!=',
+  '!==',
+  'instanceof'
+])
+
+const variableTypes = new Set([
+  'MemberExpression',
+  'Identifier'
+])
+
+const callTypes = new Set([
+  'CallExpression',
+  'NewExpression'
+])
+
+const wrapTemplate = esprima.parse('__NR_wrap()').body[0].expression
+const unwrapTemplate = esprima.parse('__NR_unwrap()').body[0].expression
+
+const mutators = [
+  new Mutator(function wrapAssignmentPredicate(token) {
+    return token.type === 'AssignmentExpression' &&
+      token.operator === '=' &&
+      functionTypes.has(token.right.type)
+  }, function injectWrapAssignment(token) {
+    token.right = wrapToken(token.right)
+  }),
+  new Mutator(function wrapArgPredicate(token) {
+    return callTypes.has(token.type)
+  }, function injectWrapArg(token) {
+    token.arguments = token.arguments.map(wrapToken)
+  }),
+  new Mutator(function unwrapPredicate(token) {
+    return token.type === 'BinaryExpression' && equalityCheckOps.has(token.operator)
+  }, function injectUnwrap(token) {
+    token.left = unwrapToken(token.left)
+    token.right = unwrapToken(token.right)
+  })
+]
+
+function wrapToken(argToken) {
+  const type = argToken.type
+  if (
+    !functionTypes.has(type) &&
+    !callTypes.has(type) &&
+    !variableTypes.has(type) ||
+    !argToken.loc
+  ) {
+    return argToken
+  }
+
+  const wrapped = Object.assign({}, wrapTemplate)
+  const lineNumberToken = Object.assign({}, lineNumberTokenTemplate)
+  lineNumberToken.value = argToken.loc.start.line
+  wrapped.arguments = [argToken, lineNumberToken, Object.assign({}, fileNameToken)]
+  return wrapped
+}
+
+function unwrapToken(argToken) {
+  if (!variableTypes.has(argToken.type)) {
+    return argToken
+  }
+
+  const wrapped = Object.assign({}, unwrapTemplate)
+  wrapped.arguments = [argToken]
+  return wrapped
+}
+
+function inject(sourceCode, file) {
+  // wrap the incoming file code to make it more palatable for esprima.
+  // node likewise wraps the contents of the file in a function, so this
+  // replicates the behavior (e.g. allows for global returns)
+  sourceCode = 'function main() {' + sourceCode + '}'
+  const sourceRootBody = esprima.parse(sourceCode, {loc: true}).body[0].body.body
+
+  const toRelax = [].concat(sourceRootBody)
+
+  while (toRelax.length) {
+    const currentToken = toRelax.pop()
+
+    mutators.forEach(m => {
+      if (m.appliesTo(currentToken)) {
+        m.add(currentToken)
+      }
+    })
+
+    for (let key of Object.keys(currentToken)) {
+      if (key === 'loc') continue
+      const value = currentToken[key]
+      if (value && value instanceof Object) {
+        if (Array.isArray(value)) {
+          for (let t of value) {
+            if (t) {
+              toRelax.push(t)
+            }
+          }
+        } else {
+          toRelax.push(value)
+        }
+      }
+    }
+  }
+
+  // TODO: make this less janky
+  fileNameToken.value = file
+  mutators.forEach(m => m.apply())
+  fileNameToken.value = null
+  // create a new base level token that contains all the statements we
+  // want to pass back to node
+  const printed = ecg.generate({
+    type: 'Program',
+    body: sourceRootBody,
+    sourceType: 'script'
+  }, {
+    format: {
+      semicolons: false
+    }
+  })
+  return printed
+}
+
+module.exports = { inject }

package/lib/instrumentation/bluebird.js

@@ -32,9 +32,10 @@ module.exports = function initialize(agent, bluebird, moduleName, shim) {
   ])
 
   shim.wrapCast(Promise, [
-    'all', 'any', 'attempt', 'bind', 'cast', 'delay', 'each', 'filter',
-    'fromCallback', 'fromNode', 'fulfilled', 'join', 'map', 'mapSeries',
-    'props', 'race', 'reduce', 'reject', 'rejected', 'resolve', 'some', 'try'
+    'all', 'allSettled', 'any', 'attempt', 'bind', 'cast', 'delay', 'each',
+    'filter', 'fromCallback', 'fromNode', 'fulfilled', 'join', 'map',
+    'mapSeries', 'props', 'race', 'reduce', 'reject', 'rejected', 'resolve',
+    'some', 'try'
   ])
   shim.wrapPromisify(Promise, ['coroutine', 'method', 'promisify'])
 

package/lib/instrumentation/core/http-outbound.js

@@ -138,6 +138,7 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
       }
     }
     segment.addAttribute('url', `${proto}//${hostname}${parsed.path}`)
+    segment.addAttribute('procedure', opts.method || 'GET')
 
     // Wrap the emit method. We're doing a special wrapper instead of using
     // `tracer.bindEmitter` because we want to do some logic based on certain

package/lib/instrumentation/mysql.js

@@ -111,13 +111,21 @@ function wrapQueriable(shim, queriable, isPoolQuery) {
   }
 
   var proto = Object.getPrototypeOf(queriable)
+
+  var describe
   if (isPoolQuery) {
-    shim.recordQuery(proto, 'query', describePoolQuery)
+    describe = describePoolQuery
   } else {
-    shim.recordQuery(proto, 'query', describeQuery)
+    describe = describeQuery
     shim.setInternalProperty(proto, '__NR_databaseName', null)
   }
 
+  shim.recordQuery(proto, 'query', describe)
+
+  if (queriable.execute) {
+    shim.recordQuery(proto, 'execute', describe)
+  }
+
   return true
 }
 

package/lib/instrumentations.js

@@ -5,7 +5,7 @@ var MODULE_TYPE = require('./shim/constants').MODULE_TYPE
 // Return a new copy of this array every time we're called
 module.exports = function instrumentations() {
   return {
-    'aws-sdk': {type: MODULE_TYPE.GENERIC},
+    'aws-sdk': {module: '@newrelic/aws-sdk'},
     'amqplib': {type: MODULE_TYPE.MESSAGE},
     'cassandra-driver': {type: MODULE_TYPE.DATASTORE},
     'connect': {type: MODULE_TYPE.WEB_FRAMEWORK},

package/lib/shimmer.js

@@ -6,6 +6,7 @@ var logger = require('./logger').child({component: 'shimmer'})
 var INSTRUMENTATIONS = require('./instrumentations')()
 var properties = require('./util/properties')
 var shims = require('./shim')
+const { inject } = require('./injector')
 
 var MODULE_TYPE = shims.constants.MODULE_TYPE
 
@@ -56,6 +57,13 @@ var CORE_INSTRUMENTATION = {
   }
 }
 
+const FORCE_MODULE_RESOLUTION_WARNING =
+  'Unable to retrieve cached path for one or more modules ' +
+  'with an already loaded parent. Forcing resolution. ' +
+  'This should not occur during normal agent execution. ' +
+  'Module resolution performance my be impacted. ' +
+  'See trace-level logs for specific modules.'
+
 /**
  * Unwrapping is only likely to be used by test code, and is a fairly drastic
  * maneuver, but it should be pretty safe if there's a desire to reboot the
@@ -342,6 +350,121 @@ var shimmer = module.exports = {
     var Module = require('module')
     var filepathMap = {}
 
+    // TODO: how do we unpatch this?
+    const diagConf = agent.config.diagnostics.code_injector
+    if (diagConf.enabled) {
+      // XXX: this is required to handle unwrapping event listener removal
+      const EEProto = require('events').EventEmitter.prototype
+      shimmer.wrapMethod(
+        EEProto,
+        'EventEmitter.prototype',
+        ['addListener', 'on', 'once', 'off', 'prependListener', 'prependOnceListener'],
+        function wrapAddListener(addListener) {
+          return function wrappedAddListener(ev, listener) {
+            return addListener.call(this, ev, __NR_unwrap(listener))
+          }
+        }
+      )
+      shimmer.wrapMethod(
+        EEProto,
+        'EventEmitter.prototype',
+        'removeListener',
+        function wrapRemoveListener(removeListener) {
+          return function wrappedRemoveListener(ev, listener) {
+            return removeListener.call(this, ev, __NR_unwrap(listener))
+          }
+        }
+      )
+      const internalCodePattern = diagConf.internal_file_pattern
+      const proto = Module.prototype
+      shimmer.wrapMethod(
+        proto,
+        'Module.prototype',
+        '_compile',
+        function wrapCompile(_compile) {
+          return function wrappedCompile(code, file) {
+            let injected
+            try {
+              injected = internalCodePattern.test(file) ? code : inject(code, file)
+              return _compile.call(this, injected, file)
+            } catch (e) {
+              logger.debug('Unable to parse file:', file, e)
+              return _compile.call(this, code, file)
+            }
+          }
+        }
+      )
+
+      // TODO: use shimmer methods
+      global.tracer = agent.tracer
+      global.__NR_wrap = __NR_wrap
+      function __NR_wrap(f, lineNum, fileName) {
+        const scheduledSegment = agent.tracer.getSegment()
+        if (
+          typeof f !== 'function' ||
+          !scheduledSegment ||
+          !scheduledSegment.transaction.isActive()
+        ) {
+          return f
+        }
+
+
+        const scheduledTransaction = scheduledSegment.transaction
+        return new Proxy(f, {
+          get: function getTrap(target, prop) {
+            // Allow for look up of the target
+            if (prop === '__NR_new_original') {
+              return target
+            }
+            return target[prop]
+          },
+          construct: function constructTrap(Target, proxyArgs) {
+            const currentSegment = agent.tracer.getSegment()
+            if (
+              scheduledTransaction.isActive() &&
+              (
+                !currentSegment ||
+                currentSegment.transaction.id !== scheduledTransaction.id
+              )
+            ) {
+              logger.info(
+                `lost state in ${fileName} (line ${lineNum});`,
+                `expected to be in transaction ${scheduledTransaction.id},`,
+                `instead landed in ${currentSegment && currentSegment.transaction.id}`
+              )
+            }
+            return new Target(...proxyArgs)
+          },
+          apply: function wrappedApply(target, thisArg, args) {
+            const currentSegment = agent.tracer.getSegment()
+            if (
+              scheduledTransaction.isActive() &&
+              (
+                !currentSegment ||
+                currentSegment.transaction.id !== scheduledTransaction.id
+              )
+            ) {
+              logger.info(
+                `lost state in ${fileName} (line ${lineNum});`,
+                `expected to be in transaction ${scheduledTransaction.id},`,
+                `instead landed in ${currentSegment && currentSegment.transaction.id}`
+              )
+            }
+            return target.apply(thisArg, args)
+          }
+        })
+      }
+
+      global.__NR_unwrap = __NR_unwrap
+      function __NR_unwrap(f) {
+        if (typeof f !== 'function' || !f || !f.__NR_new_original) {
+          return f
+        }
+
+        return f.__NR_new_original
+      }
+    }
+
     shimmer.wrapMethod(Module, 'Module', '_resolveFilename', function wrapRes(resolve) {
       return function wrappedResolveFilename(file) {
         // This is triggered by the load call, so record the path that has been seen so
@@ -353,14 +476,39 @@ var shimmer = module.exports = {
     })
 
     shimmer.wrapMethod(Module, 'Module', '_load', function wrapLoad(load) {
-      return function wrappedLoad(file) {
-        // Because we can only observe the call and return of the load function, and the
-        // load function calls resolve, we must mirror the recursive load calls with a
-        // stack.
+      return function wrappedLoad(request, parent, isMain) {
+        // _load() will invoke _resolveFilename() first time resolving a module.
         const m = load.apply(this, arguments)
-        return _postLoad(agent, m, file, filepathMap[file])
+
+        const fileName = resolveFileName(request, parent, isMain)
+        return _postLoad(agent, m, request, fileName)
       }
     })
+
+    /**
+     * Forces file name resolve for modules not in our cache when
+     * their parent has already been loaded/cached by Node.
+     * Provides a fall-back for unexpected cases that may occur.
+     * Also provides flexibilty for testing now that node 11+ caches these.
+     * @param {*} request
+     * @param {*} parent
+     * @param {*} isMain
+     */
+    function resolveFileName(request, parent, isMain) {
+      const cachedPath = filepathMap[request]
+      if (!cachedPath && parent && parent.loaded) {
+        logger.warnOnce('Force Resolution', FORCE_MODULE_RESOLUTION_WARNING)
+
+        if (logger.traceEnabled()) {
+          logger.trace(`No cached path found for ${request}. Forcing resolution.`)
+        }
+
+        // Our patched _resolveFilename will cache. No need to here.
+        return Module._resolveFilename(request, parent, isMain)
+      }
+
+      return cachedPath
+    }
   },
 
   unpatchModule: function unpatchModule() {

package/lib/spans/span-event-aggregator.js

@@ -40,7 +40,7 @@ class SpanEventAggregator extends EventAggregator {
       spanLogger.trace({
         spansCollected: this.length,
         spansSeen: this.seen
-      }, 'Entity stats on harvest')
+      }, 'Entity stats on span harvest')
     }
     super.send()
   }

package/lib/spans/span-event.js

@@ -88,7 +88,7 @@ class SpanEvent {
 
     const tx = segment.transaction
 
-    span.intrinsics.traceId = tx.traceId || tx.id
+    span.intrinsics.traceId = tx.getTraceId()
     span.intrinsics.guid = segment.id
     span.intrinsics.parentId = parentId
     span.intrinsics.transactionId = tx.id

package/lib/transaction/handle.js

@@ -35,6 +35,13 @@ module.exports = class TransactionHandle {
     this._transaction.setForceIgnore(true)
   }
 
+  /**
+  * Return whether this Transaction is being sampled
+  */
+  isSampled() {
+    return this._transaction.isSampled()
+  }
+
   /**
   *
   * Proxy method for Transaction#createDistrubtedTracePayload.
@@ -70,6 +77,10 @@ module.exports.Stub = class TransactionHandleStub {
     logger.debug("No transaction found when calling Transaction.ignore")
   }
 
+  isSampled() {
+    logger.debug("No transaction found when calling Transaction.isSampled")
+  }
+
   createDistributedTracePayload() {
     logger.debug(
       "No transaction found when calling Transaction.createDistributedTracePayload"

package/lib/transaction/index.js

@@ -72,7 +72,6 @@ function Transaction(agent) {
   )
 
   ++agent.activeTransactions
-  ++agent.transactionCreatedInHarvest
 
   this.numSegments = 0
   this.id = hashes.makeId()
@@ -972,7 +971,7 @@ function createDistributedTracePayload() {
     ac: accountId,
     ap: appId,
     tx: this.id,
-    tr: this.traceId || this.id,
+    tr: this.getTraceId(),
     pr: this.priority,
     sa: this.sampled,
     ti: Date.now()
@@ -1000,7 +999,7 @@ function addDistributedTraceIntrinsics(attrs) {
   this._calculatePriority()
 
   // *always* add these if DT flag is enabled.
-  attrs.traceId = this.traceId || this.id
+  attrs.traceId = this.getTraceId()
   attrs.guid = this.id
   attrs.priority = this.priority
 
@@ -1028,6 +1027,11 @@ function addDistributedTraceIntrinsics(attrs) {
   }
 }
 
+Transaction.prototype.isSampled = function isSampled() {
+  this._calculatePriority()
+  return this.sampled
+}
+
 /**
  * Generates a priority for the transaction if it does not have one already.
  */
@@ -1074,4 +1078,11 @@ function addRequestParameters(requestParameters) {
   }
 }
 
+/**
+ * Gets the current distributed trace traceId
+ */
+Transaction.prototype.getTraceId = function getTraceId() {
+  return this.traceId || this.id
+}
+
 module.exports = Transaction