feat: Add callback option to config to capture context when starting transactions and spans

docs/configuration.asciidoc

@@ -419,3 +419,65 @@ This is useful on scenarios where the APM server is behind a reverse proxy that
 
 NOTE: If APM Server is deployed in an origin different than the page’s origin, you will need to
 <<configuring-cors, configure Cross-Origin Resource Sharing (CORS)>>.
+
+
+[function]
+[[transaction-context-callback]]
+==== `transactionContextCallback`
+
+* *Type:* Function
+* *Default:* `null`
+
+`transactionContextCallback` allows the agent to specify a function to be called when starting automatically instrumented transactions and return context to 
+be set as tags. This enables the agent to capture data such as call stack frames and variable values from the scope when instrumented events are fired from 
+files  which do not import the RUM agent library.
+
+The following example illustrates an example which captures the stack trace:
+
+[source,js]
+----
+var options = {
+  transactionContextCallback: () => {
+    let stack
+    try {
+      throw new Error('')
+    }
+    catch (error) {
+      stack = (error as Error).stack || ''
+    }
+    stack = stack.split('\n').map(function (line) { return line.trim(); })
+    return { stack };
+  }
+}
+----
+
+
+[function]
+[[span-context-callback]]
+==== `spanContextCallback`
+
+* *Type:* Function
+* *Default:* `null`
+
+`spanContextCallback` allows the agent to specify a function to be called when starting automatically instrumented spans and return context to be set as tags. 
+This enables the agent to capture data such as call stack frames and variable values from the scope when instrumented events are fired from files  which do 
+not import the RUM agent library.
+
+The following example illustrates an example which captures the stack trace:
+
+[source,js]
+----
+var options = {
+  spanContextCallback: () => {
+    let stack
+    try {
+      throw new Error('')
+    }
+    catch (error) {
+      stack = (error as Error).stack || ''
+    }
+    stack = stack.split('\n').map(function (line) { return line.trim(); })
+    return { stack };
+  }
+}
+----

packages/rum-core/src/common/config-service.js

@@ -95,7 +95,9 @@ class Config {
       context: {},
       session: false,
       apmRequest: null,
-      sendCredentials: false
+      sendCredentials: false,
+      transactionContextCallback: null,
+      spanContextCallback: null
     }
 
     this.events = new EventHandler()

packages/rum-core/src/performance-monitoring/span.js

@@ -39,6 +39,19 @@ class Span extends SpanBase {
       this.action = fields[2]
     }
     this.sync = this.options.sync
+
+    if (
+      this.options.spanContextCallback &&
+      typeof this.options.spanContextCallback === 'function'
+    ) {
+      let tags
+      try {
+        tags = this.options.spanContextCallback()
+        this.addLabels(tags)
+      } catch (e) {
+        console.error('Failed to execute span context callback', e)
+      }
+    }
   }
 
   end(endTime, data) {

packages/rum-core/src/performance-monitoring/transaction-service.js

@@ -101,7 +101,21 @@ class TransactionService {
 
   createOptions(options) {
     const config = this._config.config
-    let presetOptions = { transactionSampleRate: config.transactionSampleRate }
+    let presetOptions = {
+      transactionSampleRate: config.transactionSampleRate
+    }
+    if (config.transactionContextCallback) {
+      presetOptions = {
+        ...presetOptions,
+        transactionContextCallback: config.transactionContextCallback
+      }
+    }
+    if (config.spanContextCallback) {
+      presetOptions = {
+        ...presetOptions,
+        spanContextCallback: config.spanContextCallback
+      }
+    }
     let perfOptions = extend(presetOptions, options)
     if (perfOptions.managed) {
       perfOptions = extend(

packages/rum-core/src/performance-monitoring/transaction.js

@@ -54,6 +54,19 @@ class Transaction extends SpanBase {
 
     this.sampleRate = this.options.transactionSampleRate
     this.sampled = Math.random() <= this.sampleRate
+
+    if (
+      this.options.transactionContextCallback &&
+      typeof this.options.transactionContextCallback === 'function'
+    ) {
+      let tags
+      try {
+        tags = this.options.transactionContextCallback()
+        this.addLabels(tags)
+      } catch (e) {
+        console.error('Failed to execute transaction context callback', e)
+      }
+    }
   }
 
   addMarks(obj) {
@@ -96,7 +109,17 @@ class Transaction extends SpanBase {
     if (this.ended) {
       return
     }
-    const opts = extend({}, options)
+    let opts = extend({}, options)
+
+    if (
+      this.options.spanContextCallback &&
+      typeof this.options.spanContextCallback === 'function'
+    ) {
+      opts = {
+        ...opts,
+        spanContextCallback: this.options.spanContextCallback
+      }
+    }
 
     opts.onEnd = trc => {
       this._onSpanEnd(trc)

packages/rum-core/test/performance-monitoring/transaction-service.spec.js

@@ -651,6 +651,61 @@ describe('TransactionService', function () {
 
       transaction.end(pageLoadTime + 1000)
     })
+
+    it('should capture tags from transaction dispatch context', done => {
+      config.setConfig({
+        transactionContextCallback: () => {
+          let stack
+          try {
+            throw new Error('')
+          } catch (error) {
+            stack = error.stack || ''
+          }
+          stack = stack.split('\n').map(function (line) {
+            return line.trim()
+          })
+          return { stack }
+        }
+      })
+      const transactionService = new TransactionService(logger, config)
+
+      const tr1 = transactionService.startTransaction(
+        'transaction1',
+        'transaction'
+      )
+
+      tr1.onEnd = () => {
+        expect(tr1.context.tags.stack).toBeTruthy()
+        done()
+      }
+      tr1.end()
+    })
+
+    it('should capture tags from span dispatch context', done => {
+      config.setConfig({
+        spanContextCallback: () => {
+          let stack
+          try {
+            throw new Error('')
+          } catch (error) {
+            stack = error.stack || ''
+          }
+          stack = stack.split('\n').map(function (line) {
+            return line.trim()
+          })
+          return { stack }
+        }
+      })
+      const transactionService = new TransactionService(logger, config)
+
+      const sp1 = transactionService.startSpan('span1', 'span')
+
+      sp1.onEnd = () => {
+        expect(sp1.context.tags.stack).toBeTruthy()
+        done()
+      }
+      sp1.end()
+    })
   })
 
   it('should truncate active spans after transaction ends', () => {

packages/rum/src/index.d.ts

@@ -107,7 +107,9 @@ declare module '@elastic/apm-rum' {
       method: string
       payload?: string
       headers?: Record<string, string>
-    }) => boolean
+    }) => boolean,
+    transactionContextCallback?: (...args: any[]) => any,
+    spanContextCallback?: (...args: any[]) => any
   }
 
   type Init = (options?: AgentConfigOptions) => ApmBase