%PDF- %PDF-
Direktori : /home/emergentqj/actioncivile/pre-auth/.8352c036a19b0051d0217d27d25e3f4a/static/node_modules/src/ |
Current File : /home/emergentqj/actioncivile/pre-auth/.8352c036a19b0051d0217d27d25e3f4a/static/node_modules/src/eventbuilder.ts |
import { getCurrentHub } from '@sentry/core'; import type { Event, EventHint, Exception, Severity, SeverityLevel, StackFrame, StackParser } from '@sentry/types'; import { addExceptionMechanism, addExceptionTypeValue, extractExceptionKeysForMessage, isDOMError, isDOMException, isError, isErrorEvent, isEvent, isPlainObject, normalizeToSize, resolvedSyncPromise, } from '@sentry/utils'; type Prototype = { constructor: (...args: unknown[]) => unknown }; /** * This function creates an exception from a JavaScript Error */ export function exceptionFromError(stackParser: StackParser, ex: Error): Exception { // Get the frames first since Opera can lose the stack if we touch anything else first const frames = parseStackFrames(stackParser, ex); const exception: Exception = { type: ex && ex.name, value: extractMessage(ex), }; if (frames.length) { exception.stacktrace = { frames }; } if (exception.type === undefined && exception.value === '') { exception.value = 'Unrecoverable error caught'; } return exception; } /** * @hidden */ export function eventFromPlainObject( stackParser: StackParser, exception: Record<string, unknown>, syntheticException?: Error, isUnhandledRejection?: boolean, ): Event { const hub = getCurrentHub(); const client = hub.getClient(); const normalizeDepth = client && client.getOptions().normalizeDepth; const event: Event = { exception: { values: [ { type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error', value: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }), }, ], }, extra: { __serialized__: normalizeToSize(exception, normalizeDepth), }, }; if (syntheticException) { const frames = parseStackFrames(stackParser, syntheticException); if (frames.length) { // event.exception.values[0] has been set above (event.exception as { values: Exception[] }).values[0].stacktrace = { frames }; } } return event; } /** * @hidden */ export function eventFromError(stackParser: StackParser, ex: Error): Event { return { exception: { values: [exceptionFromError(stackParser, ex)], }, }; } /** Parses stack frames from an error */ export function parseStackFrames( stackParser: StackParser, ex: Error & { framesToPop?: number; stacktrace?: string }, ): StackFrame[] { // Access and store the stacktrace property before doing ANYTHING // else to it because Opera is not very good at providing it // reliably in other circumstances. const stacktrace = ex.stacktrace || ex.stack || ''; const popSize = getPopSize(ex); try { return stackParser(stacktrace, popSize); } catch (e) { // no-empty } return []; } // Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108 const reactMinifiedRegexp = /Minified React error #\d+;/i; function getPopSize(ex: Error & { framesToPop?: number }): number { if (ex) { if (typeof ex.framesToPop === 'number') { return ex.framesToPop; } if (reactMinifiedRegexp.test(ex.message)) { return 1; } } return 0; } /** * There are cases where stacktrace.message is an Event object * https://github.com/getsentry/sentry-javascript/issues/1949 * In this specific case we try to extract stacktrace.message.error.message */ function extractMessage(ex: Error & { message: { error?: Error } }): string { const message = ex && ex.message; if (!message) { return 'No error message'; } if (message.error && typeof message.error.message === 'string') { return message.error.message; } return message; } /** * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`. * @hidden */ export function eventFromException( stackParser: StackParser, exception: unknown, hint?: EventHint, attachStacktrace?: boolean, ): PromiseLike<Event> { const syntheticException = (hint && hint.syntheticException) || undefined; const event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace); addExceptionMechanism(event); // defaults to { type: 'generic', handled: true } event.level = 'error'; if (hint && hint.event_id) { event.event_id = hint.event_id; } return resolvedSyncPromise(event); } /** * Builds and Event from a Message * @hidden */ export function eventFromMessage( stackParser: StackParser, message: string, // eslint-disable-next-line deprecation/deprecation level: Severity | SeverityLevel = 'info', hint?: EventHint, attachStacktrace?: boolean, ): PromiseLike<Event> { const syntheticException = (hint && hint.syntheticException) || undefined; const event = eventFromString(stackParser, message, syntheticException, attachStacktrace); event.level = level; if (hint && hint.event_id) { event.event_id = hint.event_id; } return resolvedSyncPromise(event); } /** * @hidden */ export function eventFromUnknownInput( stackParser: StackParser, exception: unknown, syntheticException?: Error, attachStacktrace?: boolean, isUnhandledRejection?: boolean, ): Event { let event: Event; if (isErrorEvent(exception as ErrorEvent) && (exception as ErrorEvent).error) { // If it is an ErrorEvent with `error` property, extract it to get actual Error const errorEvent = exception as ErrorEvent; return eventFromError(stackParser, errorEvent.error as Error); } // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`. // // https://developer.mozilla.org/en-US/docs/Web/API/DOMError // https://developer.mozilla.org/en-US/docs/Web/API/DOMException // https://webidl.spec.whatwg.org/#es-DOMException-specialness if (isDOMError(exception) || isDOMException(exception as DOMException)) { const domException = exception as DOMException; if ('stack' in (exception as Error)) { event = eventFromError(stackParser, exception as Error); } else { const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException'); const message = domException.message ? `${name}: ${domException.message}` : name; event = eventFromString(stackParser, message, syntheticException, attachStacktrace); addExceptionTypeValue(event, message); } if ('code' in domException) { // eslint-disable-next-line deprecation/deprecation event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` }; } return event; } if (isError(exception)) { // we have a real Error object, do nothing return eventFromError(stackParser, exception); } if (isPlainObject(exception) || isEvent(exception)) { // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize // it manually. This will allow us to group events based on top-level keys which is much better than creating a new // group on any key/value change. const objectException = exception as Record<string, unknown>; event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection); addExceptionMechanism(event, { synthetic: true, }); return event; } // If none of previous checks were valid, then it means that it's not: // - an instance of DOMError // - an instance of DOMException // - an instance of Event // - an instance of Error // - a valid ErrorEvent (one with an error property) // - a plain Object // // So bail out and capture it as a simple message: event = eventFromString(stackParser, exception as string, syntheticException, attachStacktrace); addExceptionTypeValue(event, `${exception}`, undefined); addExceptionMechanism(event, { synthetic: true, }); return event; } /** * @hidden */ export function eventFromString( stackParser: StackParser, input: string, syntheticException?: Error, attachStacktrace?: boolean, ): Event { const event: Event = { message: input, }; if (attachStacktrace && syntheticException) { const frames = parseStackFrames(stackParser, syntheticException); if (frames.length) { event.exception = { values: [{ value: input, stacktrace: { frames } }], }; } } return event; } function getNonErrorObjectExceptionValue( exception: Record<string, unknown>, { isUnhandledRejection }: { isUnhandledRejection?: boolean }, ): string { const keys = extractExceptionKeysForMessage(exception); const captureType = isUnhandledRejection ? 'promise rejection' : 'exception'; // Some ErrorEvent instances do not have an `error` property, which is why they are not handled before // We still want to try to get a decent message for these cases if (isErrorEvent(exception)) { return `Event \`ErrorEvent\` captured as ${captureType} with message \`${exception.message}\``; } if (isEvent(exception)) { const className = getObjectClassName(exception); return `Event \`${className}\` (type=${exception.type}) captured as ${captureType}`; } return `Object captured as ${captureType} with keys: ${keys}`; } function getObjectClassName(obj: unknown): string | undefined | void { try { const prototype: Prototype | null = Object.getPrototypeOf(obj); return prototype ? prototype.constructor.name : undefined; } catch (e) { // ignore errors here } }