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 : }
|