LCOV - code coverage report
Current view: top level - packages/telemetry/src - reportError.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 59.8 % 102 61
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type { DatadogRum } from '@datadog/browser-rum'
       2              : import type * as Sentry from '@sentry/vue'
       3              : import type { ComfyDesktop2TelemetryProperties } from '@comfyorg/comfyui-desktop-bridge-types'
       4              : import { REPORTED_ERROR_PREFIX } from '@comfyorg/shared-frontend-utils/telemetry'
       5              : import { toError } from '@comfyorg/shared-frontend-utils/errorUtil'
       6              : import { redactTelemetryValues } from './redactTelemetryUrls'
       7              : import { getDatadogRum, getFrontendBucket } from './rumContext'
       8              : export type Surface =
       9              :   | 'agent'
      10              :   | 'billing'
      11              :   | 'graph'
      12              :   | 'auth'
      13              :   | 'assets'
      14              :   | 'workspace'
      15              :   | 'platform'
      16              : export interface ReportErrorOptions {
      17              :   errorType: string
      18              :   surface: Surface
      19              :   tags?: Record<string, string | number | boolean | undefined>
      20              :   context?: Record<string, unknown>
      21              :   level?: 'warning' | 'error'
      22              :   fingerprint?: string[]
      23              :   logToConsole?: boolean
      24              : }
      25              : export interface ErrorReporterDependencies {
      26              :   captureException: typeof Sentry.captureException
      27              :   isSentryEnabled: typeof Sentry.isEnabled
      28              :   isCloud: () => boolean
      29              :   isHostTelemetryEnabled: () => boolean
      30              :   getDesktopTelemetry: () => unknown
      31              : }
      32         2356 : let dependencies: ErrorReporterDependencies | undefined
      33              : 
      34         2356 : export function configureErrorReporter(next: ErrorReporterDependencies): void {
      35         2356 :   dependencies = next
      36              : }
      37              : 
      38              : interface DeliveryState {
      39              :   sentry: boolean
      40              :   datadog: boolean
      41              :   desktop: boolean
      42              : }
      43              : interface PendingReport {
      44              :   error: Error
      45              :   options: ReportErrorOptions
      46              :   delivered: DeliveryState
      47              : }
      48         2356 : const NO_DELIVERY: DeliveryState = {
      49              :   sentry: false,
      50              :   datadog: false,
      51              :   desktop: false
      52              : }
      53         2356 : const pendingReports: PendingReport[] = []
      54         2356 : const MAX_PENDING_REPORTS = 25
      55         2356 : const reportedErrors = new WeakSet<Error>()
      56            0 : export function markErrorReported(error: Error): void {
      57            0 :   reportedErrors.add(error)
      58              : }
      59              : function liveDatadogRum(): DatadogRum | undefined {
      60              :   const rum = getDatadogRum()
      61              :   return rum?.getInitConfiguration() ? rum : undefined
      62              : }
      63         2356 : const definedEntriesOf = <V>(
      64              :   values: Record<string, V> | undefined
      65              : ): Record<string, Exclude<V, undefined>> =>
      66              :   Object.fromEntries(
      67              :     Object.entries(values ?? {}).filter(
      68              :       (entry): entry is [string, Exclude<V, undefined>] =>
      69              :         entry[1] !== undefined
      70              :     )
      71              :   )
      72         2356 : const RESERVED_TAG_KEYS = new Set(['error_type', 'level', 'surface', 'bucket'])
      73         2356 : let dispatching = false
      74         2356 : const definedTagsOf = (
      75              :   tags: ReportErrorOptions['tags']
      76              : ): Record<string, string | number | boolean> =>
      77              :   Object.fromEntries(
      78              :     Object.entries(tags ?? {}).filter(
      79              :       (entry): entry is [string, string | number | boolean] => {
      80          215 :         const [key, value] = entry
      81          215 :         return (
      82              :           !RESERVED_TAG_KEYS.has(key) &&
      83              :           (typeof value === 'string' ||
      84              :             typeof value === 'number' ||
      85              :             typeof value === 'boolean')
      86              :         )
      87              :       }
      88              :     )
      89              :   )
      90              : type DesktopCaptureException = (
      91              :   error: {
      92              :     message: string
      93              :     stack?: string
      94              :   },
      95              :   properties: ComfyDesktop2TelemetryProperties
      96              : ) => void
      97          140 : function desktopExceptionSink(): DesktopCaptureException | undefined {
      98          140 :   if (!dependencies?.isHostTelemetryEnabled()) return
      99            0 :   const telemetry = dependencies.getDesktopTelemetry()
     100          140 :   if (!telemetry || typeof telemetry !== 'object') return
     101            0 :   if (!('captureException' in telemetry)) return
     102            0 :   const capture = telemetry.captureException
     103            0 :   if (typeof capture !== 'function') return
     104            0 :   return (error, properties) => {
     105            0 :     Reflect.apply(capture, telemetry, [error, properties])
     106              :   }
     107              : }
     108          108 : function dispatchToDesktop(
     109              :   error: Error,
     110              :   errorType: string,
     111              :   surface: Surface,
     112              :   tags: Record<string, string | number | boolean>,
     113              :   level?: ReportErrorOptions['level']
     114              : ): boolean {
     115          108 :   try {
     116          108 :     const capture = desktopExceptionSink()
     117          108 :     if (!capture) return false
     118          108 :     capture(
     119              :       {
     120              :         message: error.message,
     121              :         ...(error.stack ? { stack: error.stack } : {})
     122              :       },
     123              :       {
     124              :         ...tags,
     125              :         error_type: errorType,
     126              :         surface,
     127              :         ...(level ? { level } : {})
     128              :       }
     129              :     )
     130          108 :     return true
     131              :   } catch (reporterFailure) {
     132            0 :     console.error(
     133              :       '[reportError] Desktop delivery failed',
     134              :       reporterFailure,
     135              :       error
     136              :     )
     137            0 :     return false
     138              :   }
     139              : }
     140            0 : function dispatchToSentry(
     141              :   error: Error,
     142              :   errorType: string,
     143              :   surface: Surface,
     144              :   tags: Record<string, string | number | boolean>,
     145              :   context: Record<string, unknown>,
     146              :   level: ReportErrorOptions['level'],
     147              :   fingerprint: ReportErrorOptions['fingerprint']
     148              : ): boolean {
     149            0 :   if (!dependencies) return false
     150            0 :   try {
     151            0 :     dependencies.captureException(error, {
     152              :       tags: { ...tags, error_type: errorType, surface },
     153              :       extra: context,
     154              :       level,
     155              :       ...(fingerprint ? { fingerprint } : {})
     156              :     })
     157            0 :     return true
     158              :   } catch (reporterFailure) {
     159            0 :     console.error(
     160              :       '[reportError] Sentry delivery failed',
     161              :       reporterFailure,
     162              :       error
     163              :     )
     164            0 :     return false
     165              :   }
     166              : }
     167            0 : function dispatchToDatadog(
     168              :   datadogRum: DatadogRum,
     169              :   error: Error,
     170              :   errorType: string,
     171              :   surface: Surface,
     172              :   tags: Record<string, string | number | boolean>,
     173              :   context: Record<string, unknown>,
     174              :   level: ReportErrorOptions['level']
     175              : ): boolean {
     176            0 :   try {
     177            0 :     const redactedCause = redactTelemetryValues({ cause: error.cause })?.cause
     178            0 :     const datadogError = Object.assign(new Error(error.message), error, {
     179              :       name: errorType,
     180              :       stack: error.stack,
     181              :       cause: redactedCause
     182              :     })
     183            0 :     datadogRum.addError(datadogError, {
     184              :       ...context,
     185              :       ...tags,
     186              :       error_type: errorType,
     187              :       surface,
     188              :       ...(level ? { level } : {})
     189              :     })
     190            0 :     return true
     191              :   } catch (reporterFailure) {
     192            0 :     console.error(
     193              :       '[reportError] Datadog delivery failed',
     194              :       reporterFailure,
     195              :       error
     196              :     )
     197            0 :     return false
     198              :   }
     199              : }
     200          108 : function dispatch(
     201              :   error: Error,
     202              :   options: ReportErrorOptions,
     203              :   alreadyDelivered: DeliveryState = NO_DELIVERY
     204              : ): DeliveryState {
     205          108 :   const { errorType, surface, level, fingerprint } = options
     206          108 :   const context = definedEntriesOf(options.context)
     207              :   const bucket = getFrontendBucket()
     208          108 :   const tags = {
     209              :     ...definedTagsOf(options.tags),
     210              :     ...(bucket ? { bucket } : {})
     211              :   }
     212          108 :   const sentryLive = !alreadyDelivered.sentry && dependencies?.isSentryEnabled()
     213          108 :   const datadogRum = alreadyDelivered.datadog ? undefined : liveDatadogRum()
     214          108 :   let sentryDelivered = alreadyDelivered.sentry
     215          108 :   let datadogDelivered = alreadyDelivered.datadog
     216          108 :   dispatching = true
     217          108 :   try {
     218          108 :     if (sentryLive) {
     219            0 :       sentryDelivered = dispatchToSentry(
     220              :         error,
     221              :         errorType,
     222              :         surface,
     223              :         tags,
     224              :         context,
     225              :         level,
     226              :         fingerprint
     227              :       )
     228              :     }
     229          108 :     if (datadogRum) {
     230            0 :       datadogDelivered = dispatchToDatadog(
     231              :         datadogRum,
     232              :         error,
     233              :         errorType,
     234              :         surface,
     235              :         tags,
     236              :         context,
     237              :         level
     238              :       )
     239              :     }
     240              :   } finally {
     241          108 :     dispatching = false
     242              :   }
     243          108 :   const desktopDelivered =
     244              :     alreadyDelivered.desktop ||
     245              :     dispatchToDesktop(error, errorType, surface, tags, level)
     246          108 :   return {
     247              :     sentry: sentryDelivered,
     248              :     datadog: datadogDelivered,
     249              :     desktop: desktopDelivered
     250              :   }
     251              : }
     252          108 : function enqueuePendingReport(report: PendingReport): void {
     253          108 :   if (pendingReports.length < MAX_PENDING_REPORTS) {
     254          108 :     pendingReports.push(report)
     255              :   }
     256              : }
     257          108 : function isPending(delivered: DeliveryState): boolean {
     258          108 :   return dependencies?.isCloud()
     259              :     ? !delivered.sentry || !delivered.datadog
     260              :     : !delivered.sentry && !delivered.datadog && !delivered.desktop
     261              : }
     262           32 : function hasLiveSink(): boolean {
     263           32 :   try {
     264           32 :     return (
     265              :       dependencies?.isSentryEnabled() ||
     266              :       !!liveDatadogRum() ||
     267              :       !!desktopExceptionSink()
     268              :     )
     269              :   } catch (probeFailure) {
     270            0 :     console.error('[reportError] sink probe failed', probeFailure)
     271            0 :     return false
     272              :   }
     273              : }
     274         2459 : export function flushErrorReports(): void {
     275         2459 :   if (!pendingReports.length) return
     276           32 :   if (!hasLiveSink()) return
     277            0 :   const drained = pendingReports.splice(0, pendingReports.length)
     278            0 :   for (const report of drained) {
     279            0 :     const { error, options } = report
     280            0 :     try {
     281            0 :       const delivered = dispatch(error, options, report.delivered)
     282            0 :       if (isPending(delivered)) {
     283            0 :         enqueuePendingReport({ error, options, delivered })
     284              :       }
     285              :     } catch (reporterFailure) {
     286            0 :       enqueuePendingReport(report)
     287            0 :       console.error('[reportError] failed to flush', reporterFailure, error)
     288              :     }
     289              :   }
     290              : }
     291          108 : function logReport(
     292              :   cause: unknown,
     293              :   options: ReportErrorOptions,
     294              :   suffix = ''
     295              : ): void {
     296          108 :   if (options.logToConsole === false) return
     297              :   const log = options.level === 'warning' ? console.warn : console.error
     298          108 :   log(`${REPORTED_ERROR_PREFIX}${options.errorType}${suffix}`, cause)
     299              : }
     300          108 : export function reportError(cause: unknown, options: ReportErrorOptions): void {
     301          108 :   try {
     302          108 :     if (cause instanceof Error && reportedErrors.has(cause)) return
     303          108 :     if (dispatching) {
     304            0 :       logReport(cause, options, ' (suppressed: raised while reporting)')
     305            0 :       return
     306              :     }
     307          108 :     logReport(cause, options)
     308          108 :     flushErrorReports()
     309          108 :     const error = toError(cause)
     310          108 :     const delivered = dispatch(error, options)
     311          108 :     if (isPending(delivered)) {
     312          108 :       enqueuePendingReport({ error, options, delivered })
     313              :     }
     314              :   } catch (reporterFailure) {
     315            0 :     console.error('[reportError] failed to report', reporterFailure, cause)
     316              :   }
     317              : }
        

Generated by: LCOV version 2.0-1