Revert "[RUMF-617] integrate tracing (#461)"

packages/core/src/configuration.ts

@@ -2,7 +2,6 @@ import { BuildEnv, BuildMode, Datacenter, INTAKE_SITE } from './init'
 import { includes, ONE_KILO_BYTE, ONE_SECOND } from './utils'
 
 export const DEFAULT_CONFIGURATION = {
-  allowedTracingOrigins: [] as Array<string | RegExp>,
   isCollectingError: true,
   maxErrorsByMinute: 3000,
   maxInternalMonitoringMessagesPerPage: 15,
@@ -41,7 +40,6 @@ export interface UserConfiguration {
   applicationId?: string
   internalMonitoringApiKey?: string
   isCollectingError?: boolean
-  allowedTracingOrigins?: Array<string | RegExp>
   sampleRate?: number
   resourceSampleRate?: number
   datacenter?: Datacenter // deprecated
@@ -62,7 +60,6 @@ export interface UserConfiguration {
   internalMonitoringEndpoint?: string
   logsEndpoint?: string
   rumEndpoint?: string
-  traceEndpoint?: string
 }
 
 interface ReplicaUserConfiguration {
@@ -76,10 +73,6 @@ export type Configuration = typeof DEFAULT_CONFIGURATION & {
   traceEndpoint: string
   internalMonitoringEndpoint?: string
 
-  service?: string
-  env?: string
-  version?: string
-
   isEnabled: (feature: string) => boolean
 
   // only on staging build mode
@@ -90,7 +83,6 @@ interface ReplicaConfiguration {
   applicationId?: string
   logsEndpoint: string
   rumEndpoint: string
-  traceEndpoint: string
   internalMonitoringEndpoint: string
 }
 
@@ -123,15 +115,12 @@ export function buildConfiguration(userConfiguration: UserConfiguration, buildEn
     : []
 
   const configuration: Configuration = {
-    env: userConfiguration.env,
     isEnabled: (feature: string) => {
       return includes(enableExperimentalFeatures, feature)
     },
     logsEndpoint: getEndpoint('browser', transportConfiguration),
     rumEndpoint: getEndpoint('rum', transportConfiguration),
-    service: userConfiguration.service,
     traceEndpoint: getEndpoint('public-trace', transportConfiguration),
-    version: userConfiguration.version,
     ...DEFAULT_CONFIGURATION,
   }
   if (userConfiguration.internalMonitoringApiKey) {
@@ -142,10 +131,6 @@ export function buildConfiguration(userConfiguration: UserConfiguration, buildEn
     )
   }
 
-  if ('allowedTracingOrigins' in userConfiguration) {
-    configuration.allowedTracingOrigins = userConfiguration.allowedTracingOrigins!
-  }
-
   if ('isCollectingError' in userConfiguration) {
     configuration.isCollectingError = !!userConfiguration.isCollectingError
   }
@@ -172,9 +157,6 @@ export function buildConfiguration(userConfiguration: UserConfiguration, buildEn
     if (userConfiguration.rumEndpoint !== undefined) {
       configuration.rumEndpoint = userConfiguration.rumEndpoint
     }
-    if (userConfiguration.traceEndpoint !== undefined) {
-      configuration.traceEndpoint = userConfiguration.traceEndpoint
-    }
   }
 
   if (transportConfiguration.buildMode === BuildMode.STAGING) {
@@ -194,7 +176,6 @@ export function buildConfiguration(userConfiguration: UserConfiguration, buildEn
         ),
         logsEndpoint: getEndpoint('browser', replicaTransportConfiguration),
         rumEndpoint: getEndpoint('rum', replicaTransportConfiguration),
-        traceEndpoint: getEndpoint('public-trace', replicaTransportConfiguration),
       }
     }
   }

packages/core/src/fetchProxy.ts

@@ -3,24 +3,18 @@ import { monitor } from './internalMonitoring'
 import { computeStackTrace } from './tracekit'
 import { normalizeUrl } from './urlPolyfill'
 
-export interface FetchProxy<T extends FetchContext = FetchContext> {
-  beforeSend: (callback: (context: Partial<T>) => void) => void
-  onRequestComplete: (callback: (context: T) => void) => void
+export interface FetchProxy {
+  beforeSend: (callback: (context: Partial<FetchContext>) => void) => void
+  onRequestComplete: (callback: (context: FetchContext) => void) => void
 }
 
 export interface FetchContext {
   method: string
   startTime: number
-  init?: RequestInit
   duration: number
   url: string
   status: number
   response: string
-  error?: {
-    name?: string
-    message: string
-    stack: string
-  }
   responseType?: string
 
   /**
@@ -31,10 +25,10 @@ export interface FetchContext {
 
 let fetchProxySingleton: FetchProxy | undefined
 let originalFetch: typeof window.fetch
-const beforeSendCallbacks: Array<(fetch: Partial<FetchContext>) => void> = []
-const onRequestCompleteCallbacks: Array<(fetch: FetchContext) => void> = []
+const beforeSendCallbacks: Array<(xhr: Partial<FetchContext>) => void> = []
+const onRequestCompleteCallbacks: Array<(xhr: FetchContext) => void> = []
 
-export function startFetchProxy<T extends FetchContext = FetchContext>(): FetchProxy<T> {
+export function startFetchProxy(): FetchProxy {
   if (!fetchProxySingleton) {
     proxyFetch()
     fetchProxySingleton = {
@@ -46,7 +40,7 @@ export function startFetchProxy<T extends FetchContext = FetchContext>(): FetchP
       },
     }
   }
-  return fetchProxySingleton as FetchProxy<T>
+  return fetchProxySingleton
 }
 
 export function resetFetchProxy() {
@@ -68,29 +62,20 @@ function proxyFetch() {
   // tslint:disable promise-function-async
   window.fetch = monitor(function(this: WindowOrWorkerGlobalScope['fetch'], input: RequestInfo, init?: RequestInit) {
     const method = (init && init.method) || (typeof input === 'object' && input.method) || 'GET'
-    const url = normalizeUrl((typeof input === 'object' && input.url) || (input as string))
     const startTime = performance.now()
 
     const context: Partial<FetchContext> = {
-      init,
       method,
       startTime,
-      url,
     }
 
     const reportFetch = async (response: Response | Error) => {
       context.duration = performance.now() - context.startTime!
+      context.url = normalizeUrl((typeof input === 'object' && input.url) || (input as string))
 
       if ('stack' in response || response instanceof Error) {
-        const stackTrace = computeStackTrace(response)
-        const stackTraceString = toStackTraceString(stackTrace)
         context.status = 0
-        context.error = {
-          message: stackTrace.message,
-          name: stackTrace.name,
-          stack: stackTraceString,
-        }
-        context.response = stackTraceString
+        context.response = toStackTraceString(computeStackTrace(response))
 
         onRequestCompleteCallbacks.forEach((callback) => callback(context as FetchContext))
       } else if ('status' in response) {
@@ -109,7 +94,7 @@ function proxyFetch() {
     }
     beforeSendCallbacks.forEach((callback) => callback(context))
 
-    const responsePromise = originalFetch.call(this, input, context.init)
+    const responsePromise = originalFetch.call(this, input, init)
     responsePromise.then(monitor(reportFetch), monitor(reportFetch))
     return responsePromise
   })

packages/core/src/xhrProxy.ts

@@ -5,9 +5,9 @@ interface BrowserXHR extends XMLHttpRequest {
   _datadog_xhr: Partial<XhrContext>
 }
 
-export interface XhrProxy<T extends XhrContext = XhrContext> {
-  beforeSend: (callback: (context: Partial<T>, xhr: XMLHttpRequest) => void) => void
-  onRequestComplete: (callback: (context: T) => void) => void
+export interface XhrProxy {
+  beforeSend: (callback: (context: Partial<XhrContext>) => void) => void
+  onRequestComplete: (callback: (context: XhrContext) => void) => void
 }
 
 export interface XhrContext {
@@ -25,24 +25,24 @@ export interface XhrContext {
 }
 
 let xhrProxySingleton: XhrProxy | undefined
-const beforeSendCallbacks: Array<(context: Partial<XhrContext>, xhr: XMLHttpRequest) => void> = []
+const beforeSendCallbacks: Array<(context: Partial<XhrContext>) => void> = []
 const onRequestCompleteCallbacks: Array<(context: XhrContext) => void> = []
 let originalXhrOpen: typeof XMLHttpRequest.prototype.open
 let originalXhrSend: typeof XMLHttpRequest.prototype.send
 
-export function startXhrProxy<T extends XhrContext = XhrContext>(): XhrProxy<T> {
+export function startXhrProxy(): XhrProxy {
   if (!xhrProxySingleton) {
     proxyXhr()
     xhrProxySingleton = {
-      beforeSend(callback: (context: Partial<XhrContext>, xhr: XMLHttpRequest) => void) {
+      beforeSend(callback: (context: Partial<XhrContext>) => void) {
         beforeSendCallbacks.push(callback)
       },
       onRequestComplete(callback: (context: XhrContext) => void) {
         onRequestCompleteCallbacks.push(callback)
       },
     }
   }
-  return xhrProxySingleton as XhrProxy<T>
+  return xhrProxySingleton
 }
 
 export function resetXhrProxy() {
@@ -99,7 +99,7 @@ function proxyXhr() {
 
       this.addEventListener('loadend', monitor(reportXhr))
 
-      beforeSendCallbacks.forEach((callback) => callback(this._datadog_xhr, this))
+      beforeSendCallbacks.forEach((callback) => callback(this._datadog_xhr))
     }
 
     return originalXhrSend.apply(this, arguments as any)

packages/core/test/fetchProxy.spec.ts

@@ -50,9 +50,6 @@ describe('fetch proxy', () => {
       expect(request.url).toEqual(FAKE_URL)
       expect(request.status).toEqual(0)
       expect(request.response).toMatch(/Error: fetch error/)
-      expect(request.error!.name).toBe('Error')
-      expect(request.error!.message).toBe('fetch error')
-      expect(request.error!.stack).toMatch(/Error: fetch error/)
       done()
     })
   })

packages/rum/README.md

@@ -44,7 +44,6 @@ datadogRum.init({
   - `service`: name of the corresponding service
   - `env`: environment of the service
   - `version`: version of the service
-  - `allowedTracingOrigins`: list of string or regexp of request origins in which to inject tracing headers
 
   ```
   init(configuration: {
@@ -58,7 +57,6 @@ datadogRum.init({
       service?: string,
       env?: string,
       version?: string,
-      allowedTracingOrigins?: Array<String|Regexp>,
   })
   ```