[RUMF-1176] collect other console logs new

packages/core/src/browser/consoleObservable.spec.ts

@@ -0,0 +1,61 @@
+/* eslint-disable no-console */
+import type { Subscription } from '../tools/observable'
+import { initConsoleObservable } from './consoleObservable'
+
+// TODO cover other console APIs
+describe('console error observable', () => {
+  let consoleErrorStub: jasmine.Spy
+  let consoleSubscription: Subscription
+  let notifyError: jasmine.Spy
+
+  beforeEach(() => {
+    consoleErrorStub = spyOn(console, 'error')
+    notifyError = jasmine.createSpy('notifyError')
+
+    consoleSubscription = initConsoleObservable(['error']).subscribe(notifyError)
+  })
+
+  afterEach(() => {
+    consoleSubscription.unsubscribe()
+  })
+
+  it('should keep original behavior', () => {
+    console.error('foo', 'bar')
+
+    expect(consoleErrorStub).toHaveBeenCalledWith('foo', 'bar')
+  })
+
+  it('should notify error', () => {
+    console.error('foo', 'bar')
+
+    expect(notifyError).toHaveBeenCalledWith({
+      message: 'console error: foo bar',
+      stack: undefined,
+      handlingStack: jasmine.any(String),
+      startClocks: jasmine.any(Object),
+      status: 'error',
+      source: 'console',
+    })
+  })
+
+  it('should generate a handling stack', () => {
+    function triggerError() {
+      console.error('foo', 'bar')
+    }
+    triggerError()
+    const consoleLog = notifyError.calls.mostRecent().args[0]
+    expect(consoleLog.handlingStack).toMatch(/^Error:\s+at triggerError (.|\n)*$/)
+  })
+
+  it('should allow multiple callers', () => {
+    const notifyOtherCaller = jasmine.createSpy('notifyOtherCaller')
+    const otherConsoleSubscription = initConsoleObservable(['error']).subscribe(notifyOtherCaller)
+
+    console.error('foo', 'bar')
+
+    expect(notifyError).toHaveBeenCalledTimes(1)
+    expect(notifyOtherCaller).toHaveBeenCalledTimes(1)
+
+    otherConsoleSubscription.unsubscribe()
+  })
+})

packages/core/src/browser/consoleObservable.ts

@@ -0,0 +1,82 @@
+import { callMonitored } from '../domain/internalMonitoring'
+import { computeStackTrace } from '../domain/tracekit'
+import { createHandlingStack, formatErrorMessage, toStackTraceString } from '../tools/error'
+import { mergeObservables, Observable } from '../tools/observable'
+import { find, jsonStringify } from '../tools/utils'
+
+export const ConsoleApiName = {
+  log: 'log',
+  debug: 'debug',
+  info: 'info',
+  warn: 'warn',
+  error: 'error',
+} as const
+
+type ConsoleApiNameType = typeof ConsoleApiName[keyof typeof ConsoleApiName]
+
+export interface ConsoleLog {
+  message: string
+  apiName: ConsoleApiNameType
+  stack?: string
+  handlingStack?: string
+}
+
+const consoleObservables: { [k in ConsoleApiNameType]?: Observable<ConsoleLog> } = {}
+
+export function initConsoleObservable(apis: ConsoleApiNameType[]) {
+  const observables = apis.map((api) => {
+    if (!consoleObservables[api]) {
+      consoleObservables[api] = createConsoleObservable(api)
+    }
+    return consoleObservables[api]!
+  })
+
+  return mergeObservables<ConsoleLog>(...observables)
+}
+
+/* eslint-disable no-console */
+function createConsoleObservable(api: ConsoleApiNameType) {
+  const observable = new Observable<ConsoleLog>(() => {
+    const originalConsoleApi = console[api]
+
+    console[api] = (...params: unknown[]) => {
+      originalConsoleApi.apply(console, params)
+      const handlingStack = createHandlingStack()
+
+      callMonitored(() => {
+        observable.notify(buildConsoleLog(params, api, handlingStack))
+      })
+    }
+
+    return () => {
+      console[api] = originalConsoleApi
+    }
+  })
+
+  return observable
+}
+
+function buildConsoleLog(params: unknown[], apiName: ConsoleApiNameType, handlingStack: string): ConsoleLog {
+  const log: ConsoleLog = {
+    message: [`console ${apiName}:`, ...params].map((param) => formatConsoleParameters(param)).join(' '),
+    apiName,
+  }
+
+  if (apiName === ConsoleApiName.error) {
+    const firstErrorParam = find(params, (param: unknown): param is Error => param instanceof Error)
+    log.stack = firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined
+    log.handlingStack = handlingStack
+  }
+
+  return log
+}
+
+function formatConsoleParameters(param: unknown) {
+  if (typeof param === 'string') {
+    return param
+  }
+  if (param instanceof Error) {
+    return formatErrorMessage(computeStackTrace(param))
+  }
+  return jsonStringify(param, undefined, 2)
+}

packages/core/src/index.ts

@@ -9,7 +9,6 @@ export {
   updateExperimentalFeatures,
   resetExperimentalFeatures,
 } from './domain/configuration'
-export { trackConsoleError } from './domain/error/trackConsoleError'
 export { trackRuntimeError } from './domain/error/trackRuntimeError'
 export { computeStackTrace, StackTrace } from './domain/tracekit'
 export { BuildEnv, BuildMode, defineGlobal, makePublicApi } from './boot/init'
@@ -56,6 +55,7 @@ export { Context, ContextArray, ContextValue } from './tools/context'
 export { areCookiesAuthorized, getCookie, setCookie, deleteCookie, COOKIE_ACCESS_DELAY } from './browser/cookie'
 export { initXhrObservable, XhrCompleteContext, XhrStartContext } from './browser/xhrObservable'
 export { initFetchObservable, FetchCompleteContext, FetchStartContext, FetchContext } from './browser/fetchObservable'
+export { initConsoleObservable, ConsoleLog, ConsoleApiName } from './browser/consoleObservable'
 export { BoundedBuffer } from './tools/boundedBuffer'
 export { catchUserErrors } from './tools/catchUserErrors'
 export { createContextManager } from './tools/contextManager'

packages/core/src/tools/observable.ts

@@ -27,3 +27,14 @@ export class Observable<T> {
     this.observers.forEach((observer) => observer(data))
   }
 }
+
+export function mergeObservables<T>(...observables: Array<Observable<T>>) {
+  const globalObservable = new Observable<T>(() => {
+    const subscriptions: Subscription[] = observables.map((observable) =>
+      observable.subscribe((data) => globalObservable.notify(data))
+    )
+    return () => subscriptions.forEach((subscription) => subscription.unsubscribe())
+  })
+
+  return globalObservable
+}

packages/logs/src/boot/startLogs.spec.ts

@@ -1,4 +1,4 @@
-import type { Context, RawError, RelativeTime, TimeStamp } from '@datadog/browser-core'
+import type { ConsoleLog, Context, RawError, RelativeTime, TimeStamp } from '@datadog/browser-core'
 import {
   ErrorSource,
   noop,
@@ -61,6 +61,7 @@ describe('logs', () => {
   let sessionIsTracked: boolean
   let server: sinon.SinonFakeServer
   let errorObservable: Observable<RawError>
+  let consoleObservable: Observable<ConsoleLog>
   const sessionManager: LogsSessionManager = {
     findTrackedSession: () => (sessionIsTracked ? { id: SESSION_ID } : undefined),
   }
@@ -69,12 +70,20 @@ describe('logs', () => {
     configuration: configurationOverrides,
   }: { errorLogger?: Logger; configuration?: Partial<LogsConfiguration> } = {}) => {
     const configuration = { ...baseConfiguration, ...configurationOverrides }
-    return doStartLogs(configuration, errorObservable, internalMonitoring, sessionManager, errorLogger)
+    return doStartLogs(
+      configuration,
+      errorObservable,
+      consoleObservable,
+      internalMonitoring,
+      sessionManager,
+      errorLogger
+    )
   }
 
   beforeEach(() => {
     sessionIsTracked = true
     errorObservable = new Observable<RawError>()
+    consoleObservable = new Observable<ConsoleLog>()
     server = sinon.fakeServer.create()
   })