diff --git a/packages/core/src/errors.ts b/packages/core/src/errors.ts deleted file mode 100644 index 8fcc5823..00000000 --- a/packages/core/src/errors.ts +++ /dev/null @@ -1,12 +0,0 @@ -/** - * Error triggered when event was rejected by beforeSend method - */ -export class EventRejectedError extends Error { - /** - * @param message - error message - */ - constructor(message: string) { - super(message); - this.name = 'EventRejectedError'; - } -} diff --git a/packages/core/src/users/hawk-user-manager.ts b/packages/core/src/features/hawk-user-manager.ts similarity index 97% rename from packages/core/src/users/hawk-user-manager.ts rename to packages/core/src/features/hawk-user-manager.ts index 133b5bd7..20c45162 100644 --- a/packages/core/src/users/hawk-user-manager.ts +++ b/packages/core/src/features/hawk-user-manager.ts @@ -1,5 +1,5 @@ import type { AffectedUser } from '@hawk.so/types'; -import type { HawkStorage } from '../storages/hawk-storage'; +import type { HawkStorage } from '../utils/hawk-storage'; import { id } from '../utils/id'; import type { RandomGenerator } from '../utils/random'; diff --git a/packages/core/src/modules/stack-parser.ts b/packages/core/src/features/stack-parser.ts similarity index 99% rename from packages/core/src/modules/stack-parser.ts rename to packages/core/src/features/stack-parser.ts index 8ea7518c..f3788c21 100644 --- a/packages/core/src/modules/stack-parser.ts +++ b/packages/core/src/features/stack-parser.ts @@ -1,7 +1,7 @@ import type { StackFrame } from 'error-stack-parser'; import ErrorStackParser from 'error-stack-parser'; import type { BacktraceFrame, SourceCodeLine } from '@hawk.so/types'; -import fetchTimer from './fetch-timer'; +import fetchTimer from '../utils/fetch-timer'; /** * This module prepares parsed backtrace diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts index fb1d91f7..4946b230 100644 --- a/packages/core/src/index.ts +++ b/packages/core/src/index.ts @@ -1,14 +1,15 @@ -export type { HawkStorage } from './storages/hawk-storage'; +export type { HawkStorage } from './utils/hawk-storage'; export type { RandomGenerator } from './utils/random'; -export { HawkUserManager } from './users/hawk-user-manager'; -export type { Logger, LogType } from './logger/logger'; -export { isLoggerSet, setLogger, resetLogger, log } from './logger/logger'; +export { HawkUserManager } from './features/hawk-user-manager'; +export type { Logger, LogType } from './utils/logger'; +export { isLoggerSet, setLogger, resetLogger, log } from './utils/logger'; export { validateUser, validateContext, isValidEventPayload, isValidBreadcrumb } from './utils/validation'; export { isPlainObject, isArray, isClassPrototype, isClassInstance, isString } from './utils/type-guards'; -export { Sanitizer } from './modules/sanitizer'; -export type { Transport } from './transports/transport'; -export type { SanitizerTypeHandler } from './modules/sanitizer'; -export { StackParser } from './modules/stack-parser'; +export { Sanitizer } from './utils/sanitizer'; +export type { Transport } from './utils/transport'; +export type { SanitizerTypeHandler } from './utils/sanitizer'; +export { StackParser } from './features/stack-parser'; export { buildElementSelector } from './utils/selector'; -export { EventRejectedError } from './errors'; export { isErrorProcessed, markErrorAsProcessed } from './utils/event'; +export type { BreadcrumbStore, BreadcrumbsAPI, BreadcrumbHint, BreadcrumbInput } from './types/breadcrumb-store'; +export type { MessageProcessor, ProcessingPayload } from './types/message-processor'; diff --git a/packages/core/src/types/breadcrumb-store.ts b/packages/core/src/types/breadcrumb-store.ts new file mode 100644 index 00000000..54e2eeec --- /dev/null +++ b/packages/core/src/types/breadcrumb-store.ts @@ -0,0 +1,27 @@ +import type { Breadcrumb } from '@hawk.so/types'; + +/** + * Hint passed to beforeBreadcrumb callback. + */ +export interface BreadcrumbHint { + [key: string]: unknown; +} + +/** + * Breadcrumb input type - breadcrumb data with optional timestamp. + */ +export type BreadcrumbInput = Omit & { timestamp?: number }; + +/** + * Contract for breadcrumb storage. Also serves as public breadcrumbs API. + */ +export interface BreadcrumbStore { + add(breadcrumb: BreadcrumbInput, hint?: BreadcrumbHint): void; + get(): Breadcrumb[]; + clear(): void; +} + +/** + * @deprecated Use {@link BreadcrumbStore} instead. + */ +export type BreadcrumbsAPI = BreadcrumbStore; diff --git a/packages/core/src/types/message-processor.ts b/packages/core/src/types/message-processor.ts new file mode 100644 index 00000000..817eb97f --- /dev/null +++ b/packages/core/src/types/message-processor.ts @@ -0,0 +1,43 @@ +import type { CatcherMessagePayload, CatcherMessageType } from '@hawk.so/types'; + +/** + * Extracted addons type from catcher message payload. + * + * @typeParam T - catcher message type + */ +type ExtractAddons = + CatcherMessagePayload extends { addons?: infer A } ? A : never; + +/** + * Payload type used during message processing pipeline. + * + * Same as {@link CatcherMessagePayload} but with `addons` always defined and partially filled — + * processors may contribute individual addon fields independently of each other. + * + * @typeParam T - catcher message type this payload belongs to + */ +export type ProcessingPayload = + Omit, 'addons'> & { + addons: Partial>; + }; + +/** + * Single step in message processing pipeline before message is sent. + * + * @typeParam T - catcher message type this processor handles + */ +export interface MessageProcessor { + /** + * Handles input message. May mutate, replace or drop it. + * + * Dropped message won't be sent. + * + * @param payload - processed event message payload with partially-built addons + * @param error - original error + * @returns modified payload, or `null` to drop message + */ + apply( + payload: ProcessingPayload, + error?: Error | string, + ): ProcessingPayload | null +} diff --git a/packages/core/src/utils/event.ts b/packages/core/src/utils/event.ts index ad381418..2ac9d06a 100644 --- a/packages/core/src/utils/event.ts +++ b/packages/core/src/utils/event.ts @@ -1,4 +1,4 @@ -import { log } from '../logger/logger'; +import { log } from './logger'; /** * Symbol to mark error as processed by Hawk diff --git a/packages/core/src/modules/fetch-timer.ts b/packages/core/src/utils/fetch-timer.ts similarity index 96% rename from packages/core/src/modules/fetch-timer.ts rename to packages/core/src/utils/fetch-timer.ts index 1405bfd2..398d14d9 100644 --- a/packages/core/src/modules/fetch-timer.ts +++ b/packages/core/src/utils/fetch-timer.ts @@ -1,4 +1,4 @@ -import { log } from '../logger/logger'; +import { log } from '../utils/logger'; /** * Sends AJAX request and wait for some time. diff --git a/packages/core/src/storages/hawk-storage.ts b/packages/core/src/utils/hawk-storage.ts similarity index 100% rename from packages/core/src/storages/hawk-storage.ts rename to packages/core/src/utils/hawk-storage.ts diff --git a/packages/core/src/logger/logger.ts b/packages/core/src/utils/logger.ts similarity index 100% rename from packages/core/src/logger/logger.ts rename to packages/core/src/utils/logger.ts diff --git a/packages/core/src/modules/sanitizer.ts b/packages/core/src/utils/sanitizer.ts similarity index 99% rename from packages/core/src/modules/sanitizer.ts rename to packages/core/src/utils/sanitizer.ts index ba2488ed..44289824 100644 --- a/packages/core/src/modules/sanitizer.ts +++ b/packages/core/src/utils/sanitizer.ts @@ -154,7 +154,6 @@ export class Sanitizer { depth: number, seen: WeakSet ): Record | '' | '' { - // If the maximum depth is reached, return a placeholder if (depth > Sanitizer.maxDepth) { return ''; diff --git a/packages/core/src/transports/transport.ts b/packages/core/src/utils/transport.ts similarity index 100% rename from packages/core/src/transports/transport.ts rename to packages/core/src/utils/transport.ts diff --git a/packages/core/src/utils/validation.ts b/packages/core/src/utils/validation.ts index e00c3865..8701cc6d 100644 --- a/packages/core/src/utils/validation.ts +++ b/packages/core/src/utils/validation.ts @@ -1,4 +1,4 @@ -import { log } from '../logger/logger'; +import { log } from './logger'; import type { AffectedUser, Breadcrumb, EventAddons, EventContext, EventData } from '@hawk.so/types'; import { isPlainObject } from './type-guards'; diff --git a/packages/core/tests/users/hawk-user-manager.test.ts b/packages/core/tests/instruments/hawk-user-manager.test.ts similarity index 100% rename from packages/core/tests/users/hawk-user-manager.test.ts rename to packages/core/tests/instruments/hawk-user-manager.test.ts diff --git a/packages/core/tests/logger/logger.test.ts b/packages/core/tests/utils/logger.test.ts similarity index 82% rename from packages/core/tests/logger/logger.test.ts rename to packages/core/tests/utils/logger.test.ts index 0d79fdb7..a03210ad 100644 --- a/packages/core/tests/logger/logger.test.ts +++ b/packages/core/tests/utils/logger.test.ts @@ -10,13 +10,13 @@ describe('Logger', () => { }); it('should return false from isLoggerSet when no logger has been registered', async () => { - const { isLoggerSet } = await import('../../src/logger/logger'); + const { isLoggerSet } = await import('../../src/utils/logger'); expect(isLoggerSet()).toBe(false); }); it('should return true from isLoggerSet after setLogger is called', async () => { - const { isLoggerSet, setLogger } = await import('../../src/logger/logger'); + const { isLoggerSet, setLogger } = await import('../../src/utils/logger'); setLogger(vi.fn()); @@ -24,13 +24,13 @@ describe('Logger', () => { }); it('should not throw when log is called with no logger registered', async () => { - const { log } = await import('../../src/logger/logger'); + const { log } = await import('../../src/utils/logger'); expect(() => log('test message')).not.toThrow(); }); it('should forward msg, type, and args to the registered logger', async () => { - const { setLogger, log } = await import('../../src/logger/logger'); + const { setLogger, log } = await import('../../src/utils/logger'); const mockLogger = vi.fn(); setLogger(mockLogger); @@ -41,7 +41,7 @@ describe('Logger', () => { }); it('should pass undefined for omitted type and args', async () => { - const { setLogger, log } = await import('../../src/logger/logger'); + const { setLogger, log } = await import('../../src/utils/logger'); const mockLogger = vi.fn(); setLogger(mockLogger); @@ -51,7 +51,7 @@ describe('Logger', () => { }); it('should replace a previously registered logger when setLogger is called again', async () => { - const { setLogger, log } = await import('../../src/logger/logger'); + const { setLogger, log } = await import('../../src/utils/logger'); const first = vi.fn(); const second = vi.fn(); @@ -64,7 +64,7 @@ describe('Logger', () => { }); it('should clear the registered logger when resetLogger is called', async () => { - const { isLoggerSet, setLogger, resetLogger } = await import('../../src/logger/logger'); + const { isLoggerSet, setLogger, resetLogger } = await import('../../src/utils/logger'); setLogger(vi.fn()); expect(isLoggerSet()).toBe(true); @@ -74,7 +74,7 @@ describe('Logger', () => { }); it('should become a no-op after resetLogger is called', async () => { - const { setLogger, resetLogger, log } = await import('../../src/logger/logger'); + const { setLogger, resetLogger, log } = await import('../../src/utils/logger'); const mockLogger = vi.fn(); setLogger(mockLogger); diff --git a/packages/core/tests/modules/sanitizer.test.ts b/packages/core/tests/utils/sanitizer.test.ts similarity index 100% rename from packages/core/tests/modules/sanitizer.test.ts rename to packages/core/tests/utils/sanitizer.test.ts diff --git a/packages/javascript/package.json b/packages/javascript/package.json index 7acfa8e2..20e6d310 100644 --- a/packages/javascript/package.json +++ b/packages/javascript/package.json @@ -1,6 +1,6 @@ { "name": "@hawk.so/javascript", - "version": "3.3.0", + "version": "3.3.1", "description": "JavaScript errors tracking for Hawk.so", "files": [ "dist" diff --git a/packages/javascript/src/addons/breadcrumbs.ts b/packages/javascript/src/addons/breadcrumbs.ts index c953e790..0b3be8a6 100644 --- a/packages/javascript/src/addons/breadcrumbs.ts +++ b/packages/javascript/src/addons/breadcrumbs.ts @@ -2,6 +2,7 @@ * @file Breadcrumbs module - captures chronological trail of events before an error */ import type { Breadcrumb, BreadcrumbLevel, BreadcrumbType, Json, JsonNode } from '@hawk.so/types'; +import type { BreadcrumbHint, BreadcrumbInput, BreadcrumbStore } from '@hawk.so/core'; import { buildElementSelector, isValidBreadcrumb, log, Sanitizer } from '@hawk.so/core'; /** @@ -10,9 +11,10 @@ import { buildElementSelector, isValidBreadcrumb, log, Sanitizer } from '@hawk.s const DEFAULT_MAX_BREADCRUMBS = 15; /** - * Hint object passed to beforeBreadcrumb callback + * Hint object passed to beforeBreadcrumb callback. + * Extends generic {@link BreadcrumbHint} with browser-specific data. */ -export interface BreadcrumbHint { +export interface BrowserBreadcrumbHint extends BreadcrumbHint { /** * Original event that triggered the breadcrumb (if any) */ @@ -51,7 +53,7 @@ export interface BreadcrumbsOptions { * - Return `false` — the breadcrumb will be discarded. * - Any other value is invalid — the original breadcrumb is stored as-is (a warning is logged). */ - beforeBreadcrumb?: (breadcrumb: Breadcrumb, hint?: BreadcrumbHint) => Breadcrumb | false | void; + beforeBreadcrumb?: (breadcrumb: Breadcrumb, hint?: BrowserBreadcrumbHint) => Breadcrumb | false | void; /** * Enable automatic fetch/XHR breadcrumbs @@ -75,12 +77,6 @@ export interface BreadcrumbsOptions { trackClicks?: boolean; } -/** - * Breadcrumb input type - breadcrumb data with optional timestamp - * (timestamp will be auto-generated if not provided) - */ -export type BreadcrumbInput = Omit & { timestamp?: Breadcrumb['timestamp'] }; - /** * Internal breadcrumbs options - all fields except 'beforeBreadcrumb' are required * (they have default values and are always set during init) @@ -90,17 +86,18 @@ interface InternalBreadcrumbsOptions { trackFetch: boolean; trackNavigation: boolean; trackClicks: boolean; - beforeBreadcrumb?: (breadcrumb: Breadcrumb, hint?: BreadcrumbHint) => Breadcrumb | false | void; + beforeBreadcrumb?: (breadcrumb: Breadcrumb, hint?: BrowserBreadcrumbHint) => Breadcrumb | false | void; } /** - * BreadcrumbManager - singleton that manages breadcrumb collection and storage + * Browser implementation of BreadcrumbStore. + * Singleton that manages breadcrumb collection and storage. */ -export class BreadcrumbManager { +export class BrowserBreadcrumbStore implements BreadcrumbStore { /** * Singleton instance */ - private static instance: BreadcrumbManager | null = null; + private static instance: BrowserBreadcrumbStore | null = null; /** * Breadcrumbs buffer (FIFO) @@ -167,10 +164,10 @@ export class BreadcrumbManager { /** * Get singleton instance */ - public static getInstance(): BreadcrumbManager { - BreadcrumbManager.instance ??= new BreadcrumbManager(); + public static getInstance(): BrowserBreadcrumbStore { + BrowserBreadcrumbStore.instance ??= new BrowserBreadcrumbStore(); - return BreadcrumbManager.instance; + return BrowserBreadcrumbStore.instance; } /** @@ -179,10 +176,9 @@ export class BreadcrumbManager { * @param options - Configuration options for breadcrumbs */ public init(options: BreadcrumbsOptions = {}): void { + // double-init without destroy() is a bug — call destroy() before re-initializing if (this.isInitialized) { - log('[BreadcrumbManager] init has already been called; breadcrumb configuration is global and subsequent init options are ignored.', 'warn'); - - return; + throw new Error('BrowserBreadcrumbStore is already initialized'); } this.options = { @@ -219,7 +215,7 @@ export class BreadcrumbManager { * @param hint - Optional hint object with original event data (Event, Response, XMLHttpRequest, etc.) * Used by beforeBreadcrumb callback to access original event context */ - public addBreadcrumb(breadcrumb: BreadcrumbInput, hint?: BreadcrumbHint): void { + public add(breadcrumb: BreadcrumbInput, hint?: BrowserBreadcrumbHint): void { /** * Ensure timestamp */ @@ -293,14 +289,14 @@ export class BreadcrumbManager { /** * Get current breadcrumbs snapshot (oldest to newest) */ - public getBreadcrumbs(): Breadcrumb[] { + public get(): Breadcrumb[] { return [ ...this.breadcrumbs ]; } /** * Clear all breadcrumbs */ - public clearBreadcrumbs(): void { + public clear(): void { this.breadcrumbs.length = 0; } @@ -358,9 +354,9 @@ export class BreadcrumbManager { this.popstateHandler = null; } - this.clearBreadcrumbs(); + this.clear(); this.isInitialized = false; - BreadcrumbManager.instance = null; + BrowserBreadcrumbStore.instance = null; } @@ -399,7 +395,7 @@ export class BreadcrumbManager { const duration = Date.now() - startTime; - manager.addBreadcrumb({ + manager.add({ type: 'request', category: 'fetch', message: `${response.status} ${method} ${url}`, @@ -419,7 +415,7 @@ export class BreadcrumbManager { } catch (error) { const duration = Date.now() - startTime; - manager.addBreadcrumb({ + manager.add({ type: 'request', category: 'fetch', message: `[FAIL] ${method} ${url}`, @@ -483,7 +479,7 @@ export class BreadcrumbManager { const url = this.hawkUrl || ''; const status = this.status; - manager.addBreadcrumb({ + manager.add({ type: 'request', category: 'xhr', message: `${status} ${method} ${url}`, @@ -529,7 +525,7 @@ export class BreadcrumbManager { lastUrl = to; - manager.addBreadcrumb({ + manager.add({ type: 'navigation', category: 'navigation', message: `Navigated to ${to}`, @@ -599,7 +595,7 @@ export class BreadcrumbManager { */ const text = (target.textContent || target.innerText || '').trim().substring(0, 50); - manager.addBreadcrumb({ + manager.add({ type: 'ui', category: 'ui.click', message: `Click on ${selector}`, diff --git a/packages/javascript/src/addons/browser-addon-message-processor.ts b/packages/javascript/src/addons/browser-addon-message-processor.ts new file mode 100644 index 00000000..28f66902 --- /dev/null +++ b/packages/javascript/src/addons/browser-addon-message-processor.ts @@ -0,0 +1,61 @@ +import type { MessageProcessor, ProcessingPayload } from '@hawk.so/core'; +import { type Json } from '@hawk.so/types'; + +/** + * Enriches payload with browser environment data: + * viewport dimensions, user agent, current URL, and GET parameters. + */ +export class BrowserAddonMessageProcessor implements MessageProcessor<'errors/javascript'> { + /** + * Reads current browser state (window dimensions, user agent, URL, GET params) and + * merges it into `payload.addons`, preserving any addons already set. + * + * @param payload - event message payload to enrich + * @returns modified payload with browser addons merged in + */ + public apply( + payload: ProcessingPayload<'errors/javascript'> + ): ProcessingPayload<'errors/javascript'> | null { + const { innerWidth, innerHeight } = window; + const userAgent = window.navigator.userAgent; + const url = window.location.href; + const get = this.parseGetParams(); + + payload.addons = { + ...payload.addons, + window: { + innerWidth, + innerHeight, + }, + userAgent, + url, + get, + }; + + return payload; + } + + /** + * Parses `window.location.search` into plain key-value object. + * + * @returns parsed GET parameters, or `undefined` if URL has no query string + */ + private parseGetParams(): Json | undefined { + const searchString = window.location.search.substring(1); + + if (!searchString) { + return undefined; + } + + // Create object from get-params string + const pairs = searchString.split('&'); + + return pairs.reduce((accumulator, pair) => { + const [key, value] = pair.split('='); + + accumulator[key] = value; + + return accumulator; + }, {}); + } +} diff --git a/packages/javascript/src/addons/browser-breadcrumbs-message-processor.ts b/packages/javascript/src/addons/browser-breadcrumbs-message-processor.ts new file mode 100644 index 00000000..e8f75a4d --- /dev/null +++ b/packages/javascript/src/addons/browser-breadcrumbs-message-processor.ts @@ -0,0 +1,38 @@ +import type { MessageProcessor, ProcessingPayload } from '@hawk.so/core'; +import type { BreadcrumbsOptions } from '../addons/breadcrumbs'; +import { BrowserBreadcrumbStore } from '../addons/breadcrumbs'; +import type { ErrorsCatcherType } from '@hawk.so/types/src/catchers/catcher-message'; + +/** + * Attaches breadcrumbs to payload. + */ +export class BrowserBreadcrumbsMessageProcessor implements MessageProcessor { + /** + * Initialize message processor including {@link BrowserBreadcrumbStore} initialization. + * + * @param options {@link BrowserBreadcrumbStore} settings required for initialization. + */ + constructor(options: BreadcrumbsOptions = {}) { + const breadcrumbStore = BrowserBreadcrumbStore.getInstance(); + + breadcrumbStore.init(options); + } + + /** + * Sets `payload.breadcrumbs` from snapshot if non-empty; skips otherwise. + * + * @param payload - event message payload to enrich + * @returns modified payload with breadcrumbs set, or original payload unchanged + */ + public apply( + payload: ProcessingPayload + ): ProcessingPayload | null { + const breadcrumbs = BrowserBreadcrumbStore.getInstance().get(); + + if (breadcrumbs.length > 0) { + payload.breadcrumbs = breadcrumbs; + } + + return payload; + } +} diff --git a/packages/javascript/src/addons/console-output-addon-message-processor.ts b/packages/javascript/src/addons/console-output-addon-message-processor.ts new file mode 100644 index 00000000..36e1e937 --- /dev/null +++ b/packages/javascript/src/addons/console-output-addon-message-processor.ts @@ -0,0 +1,38 @@ +import type { MessageProcessor, ProcessingPayload } from '@hawk.so/core'; +import type { ConsoleCatcher } from '../addons/consoleCatcher'; + +/** + * Attaches captured console output to payload addons. + */ +export class ConsoleOutputAddonMessageProcessor implements MessageProcessor<'errors/javascript'> { + private readonly consoleCatcher: ConsoleCatcher; + + /** + * Stores catcher reference and starts console interception. + * + * @param consoleCatcher - console catcher instance to read logs from + */ + constructor(consoleCatcher: ConsoleCatcher) { + this.consoleCatcher = consoleCatcher; + this.consoleCatcher.init(); + } + + /** + * Attaches current console log stack to `payload.addons.consoleOutput`. + * Skips if log stack is empty. + * + * @param payload - event message payload to enrich + * @returns modified payload with console logs attached, or original payload unchanged + */ + public apply( + payload: ProcessingPayload<'errors/javascript'> + ): ProcessingPayload<'errors/javascript'> | null { + const logs = this.consoleCatcher?.getConsoleLogStack(); + + if (logs && logs.length > 0) { + payload.addons.consoleOutput = logs; + } + + return payload; + } +} diff --git a/packages/javascript/src/addons/debug-addon-message-processor.ts b/packages/javascript/src/addons/debug-addon-message-processor.ts new file mode 100644 index 00000000..9b0694be --- /dev/null +++ b/packages/javascript/src/addons/debug-addon-message-processor.ts @@ -0,0 +1,31 @@ +import type { MessageProcessor, ProcessingPayload } from '@hawk.so/core'; + +/** + * Appends `RAW_EVENT_DATA` to the event addons for debug purposes. + */ +export class DebugAddonMessageProcessor implements MessageProcessor<'errors/javascript'> { + /** + * Writes name, message, and stack from `snapshot.error` into `payload.addons.RAW_EVENT_DATA`. + * Skips if snapshot error is missing or not Error instance. + * + * @param payload - event message payload to enrich + * @param error - original error + * @returns modified payload with RAW_EVENT_DATA set, or original payload unchanged + */ + public apply( + payload: ProcessingPayload<'errors/javascript'>, + error?: Error | string + ): ProcessingPayload<'errors/javascript'> | null { + if (!(error instanceof Error)) { + return payload; + } + + payload.addons.RAW_EVENT_DATA = { + name: error.name, + message: error.message, + stack: error.stack ?? '', + }; + + return payload; + } +} diff --git a/packages/javascript/src/addons/userAgentInfo.ts b/packages/javascript/src/addons/userAgentInfo.ts deleted file mode 100644 index ec7c3706..00000000 --- a/packages/javascript/src/addons/userAgentInfo.ts +++ /dev/null @@ -1,17 +0,0 @@ -/** - * @file Integration for adding User Agent info - */ - -/** - * @param event - event to modify - * @param data - event data - */ -export default function (event, data): void { - data.payload.userAgent = { - name: window.navigator.userAgent, - frame: { - width: window.innerWidth, - height: window.innerHeight, - }, - }; -} diff --git a/packages/javascript/src/catcher.ts b/packages/javascript/src/catcher.ts index 3aa0a2aa..b148d888 100644 --- a/packages/javascript/src/catcher.ts +++ b/packages/javascript/src/catcher.ts @@ -1,23 +1,22 @@ import './modules/element-sanitizer'; import Socket from './modules/socket'; -import type { BreadcrumbsAPI, CatcherMessage, HawkInitialSettings, HawkJavaScriptEvent, Transport } from './types'; +import type { CatcherMessage, HawkInitialSettings, HawkJavaScriptEvent, Transport } from './types'; import { isPerformanceIssueDetectorEnabled } from './types/issues'; import { VueIntegration } from './integrations/vue'; import type { AffectedUser, + CatcherMessagePayload, DecodedIntegrationToken, EncodedIntegrationToken, EventContext, - JavaScriptAddons, - Json, VueIntegrationAddons } from '@hawk.so/types'; import type { JavaScriptCatcherIntegrations } from '@/types'; import { ConsoleCatcher } from './addons/consoleCatcher'; -import { BreadcrumbManager } from './addons/breadcrumbs'; +import { BrowserBreadcrumbStore } from './addons/breadcrumbs'; +import type { BreadcrumbStore, MessageProcessor, ProcessingPayload } from '@hawk.so/core'; import { PerformanceIssuesMonitor } from './addons/performance-issues'; import { - EventRejectedError, HawkUserManager, isErrorProcessed, isLoggerSet, @@ -30,9 +29,14 @@ import { validateContext, validateUser } from '@hawk.so/core'; -import { HawkLocalStorage } from './storages/hawk-local-storage'; -import { createBrowserLogger } from './logger/logger'; +import { HawkLocalStorage } from './utils/hawk-local-storage'; +import { createBrowserLogger } from './utils/logger'; import { BrowserRandomGenerator } from './utils/random'; +import { BrowserAddonMessageProcessor } from './addons/browser-addon-message-processor'; +import { ConsoleOutputAddonMessageProcessor } from './addons/console-output-addon-message-processor'; +import { DebugAddonMessageProcessor } from './addons/debug-addon-message-processor'; +import { BrowserBreadcrumbsMessageProcessor } from './addons/browser-breadcrumbs-message-processor'; + /** * Allow to use global VERSION, that will be overwritten by Webpack */ @@ -122,9 +126,9 @@ export default class Catcher { private readonly consoleCatcher: ConsoleCatcher | null = null; /** - * Breadcrumb manager instance + * Breadcrumb store instance */ - private readonly breadcrumbManager: BreadcrumbManager | null; + private readonly breadcrumbStore: BrowserBreadcrumbStore | null = null; /** * Issues monitor instance @@ -139,6 +143,11 @@ export default class Catcher { new BrowserRandomGenerator() ); + /** + * Ordered list of message processors applied to every outgoing event message. + */ + private readonly messageProcessors: MessageProcessor[]; + /** * Catcher constructor * @@ -167,6 +176,9 @@ export default class Catcher { settings.consoleTracking !== null && settings.consoleTracking !== undefined ? settings.consoleTracking : true; + this.messageProcessors = [ + new BrowserAddonMessageProcessor(), + ]; if (!this.token) { log( @@ -194,17 +206,19 @@ export default class Catcher { if (this.consoleTracking) { this.consoleCatcher = ConsoleCatcher.getInstance(); - this.consoleCatcher.init(); + this.messageProcessors.push(new ConsoleOutputAddonMessageProcessor(this.consoleCatcher)); } /** * Initialize breadcrumbs */ if (settings.breadcrumbs !== false) { - this.breadcrumbManager = BreadcrumbManager.getInstance(); - this.breadcrumbManager.init(settings.breadcrumbs ?? {}); - } else { - this.breadcrumbManager = null; + this.breadcrumbStore = BrowserBreadcrumbStore.getInstance(); + this.messageProcessors.push(new BrowserBreadcrumbsMessageProcessor(settings.breadcrumbs ?? {})); + } + + if (this.debug) { + this.messageProcessors.push(new DebugAddonMessageProcessor()); } this.configureIssues(settings); @@ -298,11 +312,11 @@ export default class Catcher { * data: { userId: '123' } * }); */ - public get breadcrumbs(): BreadcrumbsAPI { + public get breadcrumbs(): BreadcrumbStore { return { - add: (breadcrumb, hint) => this.breadcrumbManager?.addBreadcrumb(breadcrumb, hint), - get: () => this.breadcrumbManager?.getBreadcrumbs() ?? [], - clear: () => this.breadcrumbManager?.clearBreadcrumbs(), + add: (breadcrumb, hint) => this.breadcrumbStore?.add(breadcrumb, hint), + get: () => this.breadcrumbStore?.get() ?? [], + clear: () => this.breadcrumbStore?.clear(), }; } @@ -391,7 +405,12 @@ export default class Catcher { } /** - * Format and send an error + * Process and sends error message. + * + * Returns early without sending either if + * - error was already processed, + * - message processor drops it + * - {@link beforeSend} hook rejects it * * @param error - error to send * @param integrationAddons - addons spoiled by Integration @@ -415,105 +434,119 @@ export default class Catcher { markErrorAsProcessed(error); } - const errorFormatted = await this.prepareErrorFormatted(error, context); + let processingPayload = await this.buildBasePayload(error, context); + + for (const processor of this.messageProcessors) { + const result = processor.apply(processingPayload, error); + + if (result === null) { + return; + } + + processingPayload = result; + } + + const payload = processingPayload as CatcherMessagePayload; - /** - * If this event caught by integration (Vue or other), it can pass extra addons - */ if (integrationAddons) { - this.appendIntegrationAddons(errorFormatted, Sanitizer.sanitize(integrationAddons)); + payload.addons = { + ...(payload.addons ?? {}), + ...Sanitizer.sanitize(integrationAddons), + }; } - this.sendErrorFormatted(errorFormatted); - } catch (e) { - if (e instanceof EventRejectedError) { - /** - * Event was rejected by user using the beforeSend method - */ + const payloadPostBeforeSend = this.applyBeforeSendHook(payload); + + if (payloadPostBeforeSend === null) { + // Event was rejected by user using the beforeSend method return; } + this.sendMessage({ + token: this.token, + catcherType: Catcher.type, + payload: payloadPostBeforeSend, + } as CatcherMessage); + } catch (e) { log('Unable to send error. Seems like it is Hawk internal bug. Please, report it here: https://github.com/codex-team/hawk.javascript/issues/new', 'warn', e); } } /** - * Sends formatted HawkEvent to the Collector - * - * @param errorFormatted - formatted error to send - */ - private sendErrorFormatted(errorFormatted: CatcherMessage): void { - this.transport.send(errorFormatted) - .catch((sendingError) => { - log('WebSocket sending error', 'error', sendingError); - }); - } - - /** - * Formats the event + * Builds base event payload with basic fields (title, type, backtrace, user, context, release). * - * @param error - error to format - * @param context - any additional data passed by user + * @param error - caught error or string reason + * @param context - per-call context to merge with instance-level context + * @returns base payload with core data */ - private async prepareErrorFormatted(error: Error | string, context?: EventContext): Promise> { - let payload: HawkJavaScriptEvent = { + private async buildBasePayload( + error: Error | string, + context?: EventContext + ): Promise> { + return { title: this.getTitle(error), type: this.getType(error), release: this.getRelease(), - breadcrumbs: this.getBreadcrumbsForEvent(), context: this.getContext(context), user: this.getUser(), - addons: this.getAddons(error), backtrace: await this.getBacktrace(error), catcherVersion: this.version, + addons: {}, }; + } - /** - * Filter sensitive data - */ - if (typeof this.beforeSend === 'function') { - let eventPayloadClone: HawkJavaScriptEvent; + /** + * Clones {@link payload} and applies user-supplied {@link beforeSend} hook against it. + * + * @param payload - processed event message payload + * @returns possibly modified payload, or null if the event should be dropped + */ + private applyBeforeSendHook( + payload: CatcherMessagePayload + ): CatcherMessagePayload | null { + if (typeof this.beforeSend !== 'function') { + return payload; + } - try { - eventPayloadClone = structuredClone(payload); - } catch { - /** - * structuredClone may fail on non-cloneable values (functions, DOM nodes, etc.) - * Fall back to passing the original — hook may mutate it, but at least reporting won't crash - */ - eventPayloadClone = payload; - } + let clone: CatcherMessagePayload; - const result = this.beforeSend(eventPayloadClone); + try { + clone = structuredClone(payload); + } catch { + // structuredClone may fail on non-cloneable values (functions, DOM nodes, etc.) + // Fall back to passing the original — hook may mutate it, but at least reporting won't crash + clone = payload; + } - /** - * false → drop event - */ - if (result === false) { - throw new EventRejectedError('Event rejected by beforeSend method.'); - } + const result = this.beforeSend(clone); - /** - * Valid event payload → use it instead of original - */ - if (isValidEventPayload(result)) { - payload = result as HawkJavaScriptEvent; - } else { - /** - * Anything else is invalid — warn, payload stays untouched (hook only received a clone) - */ - log( - 'Invalid beforeSend value. It should return event or false. Event is sent without changes.', - 'warn' - ); - } + // false → drop event + if (result === false) { + return null; } - return { - token: this.token, - catcherType: Catcher.type, - payload, - }; + // Valid event payload → use it instead of original + if (isValidEventPayload(result)) { + return result as CatcherMessagePayload; + } + + // Anything else is invalid — warn, payload stays untouched (hook only received a clone) + log( + 'Invalid beforeSend value. It should return event or false. Event is sent without changes.', + 'warn' + ); + + return payload; + } + + /** + * Dispatches assembled message over configured transport. + * + * @param message - fully assembled catcher message ready to send + */ + private sendMessage(message: CatcherMessage): void { + this.transport.send(message) + .catch((e) => log('Transport sending error', 'error', e)); } /** @@ -605,39 +638,6 @@ export default class Catcher { return this.userManager.getUser(); } - /** - * Get breadcrumbs for event payload - */ - private getBreadcrumbsForEvent(): HawkJavaScriptEvent['breadcrumbs'] { - const breadcrumbs = this.breadcrumbManager?.getBreadcrumbs(); - - return breadcrumbs && breadcrumbs.length > 0 ? breadcrumbs : undefined; - } - - /** - * Get parameters - */ - private getGetParams(): Json | null { - const searchString = window.location.search.substr(1); - - if (!searchString) { - return null; - } - - /** - * Create object from get-params string - */ - const pairs = searchString.split('&'); - - return pairs.reduce((accumulator, pair) => { - const [key, value] = pair.split('='); - - accumulator[key] = value; - - return accumulator; - }, {}); - } - /** * Return parsed backtrace information * @@ -662,77 +662,4 @@ export default class Catcher { return undefined; } } - - /** - * Return some details - * - * @param {Error|string} error — caught error - */ - private getAddons(error: Error | string): HawkJavaScriptEvent['addons'] { - const { innerWidth, innerHeight } = window; - const userAgent = window.navigator.userAgent; - const location = window.location.href; - const getParams = this.getGetParams(); - const consoleLogs = this.consoleTracking && this.consoleCatcher?.getConsoleLogStack(); - - const addons: JavaScriptAddons = { - window: { - innerWidth, - innerHeight, - }, - userAgent, - url: location, - }; - - if (getParams) { - addons.get = getParams; - } - - if (this.debug) { - addons.RAW_EVENT_DATA = this.getRawData(error); - } - - if (consoleLogs && consoleLogs.length > 0) { - addons.consoleOutput = consoleLogs; - } - - return addons; - } - - /** - * Compose raw data object - * - * @param {Error|string} error — caught error - */ - private getRawData(error: Error | string): Json | undefined { - if (!(error instanceof Error)) { - return; - } - - const stack = error.stack !== null && error.stack !== undefined ? error.stack : ''; - - return { - name: error.name, - message: error.message, - stack, - }; - } - - /** - * Extend addons object with addons spoiled by integration - * This method mutates original event - * - * @param errorFormatted - Hawk event prepared for sending - * @param integrationAddons - extra addons - */ - private appendIntegrationAddons(errorFormatted: CatcherMessage, integrationAddons: JavaScriptCatcherIntegrations): void { - /** - * Some integrations may pass a payload without `addons`. - * Create it first, then merge integration data. - */ - if (errorFormatted.payload.addons === undefined) { - errorFormatted.payload.addons = {} as JavaScriptAddons; - } - Object.assign(errorFormatted.payload.addons, integrationAddons); - } } diff --git a/packages/javascript/src/types/breadcrumbs-api.ts b/packages/javascript/src/types/breadcrumbs-api.ts deleted file mode 100644 index 777dcdf3..00000000 --- a/packages/javascript/src/types/breadcrumbs-api.ts +++ /dev/null @@ -1,11 +0,0 @@ -import type { Breadcrumb } from '@hawk.so/types'; -import type { BreadcrumbInput, BreadcrumbHint } from '../addons/breadcrumbs'; - -/** - * Breadcrumbs API interface - */ -export interface BreadcrumbsAPI { - add: (breadcrumb: BreadcrumbInput, hint?: BreadcrumbHint) => void; - get: () => Breadcrumb[]; - clear: () => void; -} diff --git a/packages/javascript/src/types/hawk-initial-settings.ts b/packages/javascript/src/types/hawk-initial-settings.ts index b44b2ffc..661bc321 100644 --- a/packages/javascript/src/types/hawk-initial-settings.ts +++ b/packages/javascript/src/types/hawk-initial-settings.ts @@ -110,4 +110,5 @@ export interface HawkInitialSettings { * Manual sending via `.send()` still works. */ issues?: false | IssuesOptions; + } diff --git a/packages/javascript/src/types/index.ts b/packages/javascript/src/types/index.ts index b6144027..291b8198 100644 --- a/packages/javascript/src/types/index.ts +++ b/packages/javascript/src/types/index.ts @@ -5,9 +5,14 @@ import type { PerformanceIssueThresholdOptions } from './issues'; import type { Transport } from '@hawk.so/core'; +import type { BreadcrumbsAPI, BreadcrumbStore } from '@hawk.so/core'; import type { HawkJavaScriptEvent } from './event'; -import type { VueIntegrationData, NuxtIntegrationData, NuxtIntegrationAddons, JavaScriptCatcherIntegrations } from './integrations'; -import type { BreadcrumbsAPI } from './breadcrumbs-api'; +import type { + JavaScriptCatcherIntegrations, + NuxtIntegrationAddons, + NuxtIntegrationData, + VueIntegrationData +} from './integrations'; export type { CatcherMessage, HawkInitialSettings, @@ -19,5 +24,6 @@ export type { NuxtIntegrationData, NuxtIntegrationAddons, JavaScriptCatcherIntegrations, + BreadcrumbStore, BreadcrumbsAPI }; diff --git a/packages/javascript/src/storages/hawk-local-storage.ts b/packages/javascript/src/utils/hawk-local-storage.ts similarity index 100% rename from packages/javascript/src/storages/hawk-local-storage.ts rename to packages/javascript/src/utils/hawk-local-storage.ts diff --git a/packages/javascript/src/logger/logger.ts b/packages/javascript/src/utils/logger.ts similarity index 100% rename from packages/javascript/src/logger/logger.ts rename to packages/javascript/src/utils/logger.ts diff --git a/packages/javascript/tests/addons/breadcrumbs-message-processor.test.ts b/packages/javascript/tests/addons/breadcrumbs-message-processor.test.ts new file mode 100644 index 00000000..cfe375c6 --- /dev/null +++ b/packages/javascript/tests/addons/breadcrumbs-message-processor.test.ts @@ -0,0 +1,28 @@ +import { beforeEach, describe, expect, it, vi } from 'vitest'; +import { makePayload } from './message-processor.helpers'; +import { BrowserBreadcrumbsMessageProcessor } from '../../src/addons/browser-breadcrumbs-message-processor'; +import { BrowserBreadcrumbStore } from '../../src/addons/breadcrumbs'; + +describe('BreadcrumbsMessageProcessor', () => { + const processor = new BrowserBreadcrumbsMessageProcessor(); + + beforeEach(() => { + BrowserBreadcrumbStore.getInstance().clear() + }); + + it('should attach breadcrumbs from snapshot to payload', () => { + const breadcrumbs = { message: 'click', timestamp: 1 }; + BrowserBreadcrumbStore.getInstance().add(breadcrumbs) + + const result = processor.apply(makePayload()); + + expect(result?.breadcrumbs).toHaveLength(1) + expect(result?.breadcrumbs).toContainEqual(breadcrumbs); + }); + + it('should not set payload breadcrumbs when breadcrumb store is empty', () => { + const result = processor.apply(makePayload()); + + expect(result?.breadcrumbs).toBeUndefined(); + }); +}); diff --git a/packages/javascript/tests/addons/browser-message-processor.test.ts b/packages/javascript/tests/addons/browser-message-processor.test.ts new file mode 100644 index 00000000..02e22aae --- /dev/null +++ b/packages/javascript/tests/addons/browser-message-processor.test.ts @@ -0,0 +1,48 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; +import { BrowserAddonMessageProcessor } from '../../src/addons/browser-addon-message-processor'; +import { makePayload } from './message-processor.helpers'; + +describe('BrowserMessageProcessor', () => { + beforeEach(() => { + vi.stubGlobal('location', { href: 'http://localhost/', search: '' }); + vi.stubGlobal('navigator', { userAgent: 'test-agent' }); + vi.stubGlobal('innerWidth', 1280); + vi.stubGlobal('innerHeight', 720); + }); + + afterEach(() => { + vi.unstubAllGlobals(); + }); + + it('should set window dimensions, userAgent, and url', () => { + const result = new BrowserAddonMessageProcessor().apply(makePayload()); + + expect(result?.addons).toMatchObject({ + window: { innerWidth: 1280, innerHeight: 720 }, + userAgent: 'test-agent', + url: 'http://localhost/', + }); + }); + + it('should parse GET parameters from the URL', () => { + vi.stubGlobal('location', { href: 'http://localhost/?foo=bar&baz=qux', search: '?foo=bar&baz=qux' }); + + const result = new BrowserAddonMessageProcessor().apply(makePayload()); + + expect(result?.addons?.get).toEqual({ foo: 'bar', baz: 'qux' }); + }); + + it('should omit get when URL has no query string', () => { + const result = new BrowserAddonMessageProcessor().apply(makePayload()); + + expect(result?.addons?.get).toBeUndefined(); + }); + + it('should merge with existing payload addons', () => { + const payload = makePayload({ addons: { consoleOutput: [{ message: 'log' }] } }); + const result = new BrowserAddonMessageProcessor().apply(payload); + + expect(result?.addons?.consoleOutput).toBeDefined(); + expect(result?.addons?.userAgent).toBeDefined(); + }); +}); diff --git a/packages/javascript/tests/addons/console-catcher-message-processor.test.ts b/packages/javascript/tests/addons/console-catcher-message-processor.test.ts new file mode 100644 index 00000000..f28b6f67 --- /dev/null +++ b/packages/javascript/tests/addons/console-catcher-message-processor.test.ts @@ -0,0 +1,28 @@ +import { describe, expect, it, vi } from 'vitest'; +import { ConsoleOutputAddonMessageProcessor } from '../../src/addons/console-output-addon-message-processor'; +import { makePayload } from './message-processor.helpers'; + +const makeConsoleCatcher = (logs: any[]) => ({ + init: vi.fn(), + getConsoleLogStack: vi.fn().mockReturnValue(logs), + addErrorEvent: vi.fn(), +}); + +describe('ConsoleCatcherMessageProcessor', () => { + it('should attach console logs to payload addons', () => { + const logs = [{ message: 'hello', type: 'log' }]; + const processor = new ConsoleOutputAddonMessageProcessor(makeConsoleCatcher(logs) as any); + + const result = processor.apply(makePayload()); + + expect(result?.addons?.consoleOutput).toEqual(logs); + }); + + it('should not add consoleOutput when log stack is empty', () => { + const processor = new ConsoleOutputAddonMessageProcessor(makeConsoleCatcher([]) as any); + + const result = processor.apply(makePayload()); + + expect(result?.addons?.consoleOutput).toBeUndefined(); + }); +}); diff --git a/packages/javascript/tests/addons/debug-message-processor.test.ts b/packages/javascript/tests/addons/debug-message-processor.test.ts new file mode 100644 index 00000000..0116605a --- /dev/null +++ b/packages/javascript/tests/addons/debug-message-processor.test.ts @@ -0,0 +1,31 @@ +import { describe, expect, it } from 'vitest'; +import { DebugAddonMessageProcessor } from '../../src/addons/debug-addon-message-processor'; +import { makePayload } from './message-processor.helpers'; + +describe('DebugMessageProcessor', () => { + const processor = new DebugAddonMessageProcessor(); + + it('should add RAW_EVENT_DATA when hint.error is an Error instance', () => { + const error = new TypeError('boom'); + + const result = processor.apply(makePayload(), error); + + expect(result?.addons?.RAW_EVENT_DATA).toMatchObject({ + name: 'TypeError', + message: 'boom', + stack: expect.any(String), + }); + }); + + it('should not add RAW_EVENT_DATA when hint.error is a string', () => { + const result = processor.apply(makePayload(), 'string reason'); + + expect(result?.addons?.RAW_EVENT_DATA).toBeUndefined(); + }); + + it('should not add RAW_EVENT_DATA when hint is absent', () => { + const result = processor.apply(makePayload()); + + expect(result?.addons?.RAW_EVENT_DATA).toBeUndefined(); + }); +}); diff --git a/packages/javascript/tests/addons/message-processor.helpers.ts b/packages/javascript/tests/addons/message-processor.helpers.ts new file mode 100644 index 00000000..ce654525 --- /dev/null +++ b/packages/javascript/tests/addons/message-processor.helpers.ts @@ -0,0 +1,7 @@ +import type { ProcessingPayload } from '@hawk.so/core'; + +export function makePayload( + overrides: Partial> = {} +): ProcessingPayload<'errors/javascript'> { + return { title: 'Test error', catcherVersion: '0.0.0', addons: {}, ...overrides }; +} diff --git a/packages/javascript/tests/breadcrumbs.test.ts b/packages/javascript/tests/breadcrumbs.test.ts index 7afec05c..6830c4da 100644 --- a/packages/javascript/tests/breadcrumbs.test.ts +++ b/packages/javascript/tests/breadcrumbs.test.ts @@ -1,14 +1,14 @@ -import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'; -import { BreadcrumbManager } from '../src/addons/breadcrumbs'; +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; +import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs'; import type { Breadcrumb } from '@hawk.so/types'; import * as core from '@hawk.so/core'; function resetManager(): void { // eslint-disable-next-line @typescript-eslint/no-explicit-any - (BreadcrumbManager as any).instance = null; + (BrowserBreadcrumbStore as any).instance?.destroy(); } -describe('BreadcrumbManager', () => { +describe('BrowserBreadcrumbStore', () => { let logSpy: ReturnType; beforeEach(() => { @@ -21,19 +21,19 @@ describe('BreadcrumbManager', () => { }); it('should return empty array when no breadcrumbs added', () => { - const m = BreadcrumbManager.getInstance(); + const m = BrowserBreadcrumbStore.getInstance(); m.init(); - expect(m.getBreadcrumbs()).toEqual([]); + expect(m.get()).toEqual([]); }); it('should store breadcrumb with auto-generated timestamp', () => { - const m = BreadcrumbManager.getInstance(); + const m = BrowserBreadcrumbStore.getInstance(); m.init(); - m.addBreadcrumb({ type: 'default', message: 'test', level: 'info' }); + m.add({ type: 'default', message: 'test', level: 'info' }); - const crumbs = m.getBreadcrumbs(); + const crumbs = m.get(); expect(crumbs).toHaveLength(1); expect(crumbs[0].message).toBe('test'); @@ -41,24 +41,24 @@ describe('BreadcrumbManager', () => { }); it('should keep explicit timestamp as-is', () => { - const m = BreadcrumbManager.getInstance(); + const m = BrowserBreadcrumbStore.getInstance(); m.init(); - m.addBreadcrumb({ type: 'default', message: 'test', level: 'info', timestamp: 12345 }); + m.add({ type: 'default', message: 'test', level: 'info', timestamp: 12345 }); - expect(m.getBreadcrumbs()[0].timestamp).toBe(12345); + expect(m.get()[0].timestamp).toBe(12345); }); it('should drop oldest breadcrumbs when buffer overflows (FIFO)', () => { - const m = BreadcrumbManager.getInstance(); + const m = BrowserBreadcrumbStore.getInstance(); m.init({ maxBreadcrumbs: 3 }); for (let i = 0; i < 5; i++) { - m.addBreadcrumb({ type: 'default', message: `msg-${i}`, level: 'info' }); + m.add({ type: 'default', message: `msg-${i}`, level: 'info' }); } - const crumbs = m.getBreadcrumbs(); + const crumbs = m.get(); expect(crumbs).toHaveLength(3); expect(crumbs[0].message).toBe('msg-2'); @@ -66,55 +66,59 @@ describe('BreadcrumbManager', () => { }); it('should store max 15 breadcrumbs by default', () => { - const m = BreadcrumbManager.getInstance(); + const m = BrowserBreadcrumbStore.getInstance(); m.init(); for (let i = 0; i < 20; i++) { - m.addBreadcrumb({ type: 'default', message: `msg-${i}`, level: 'info' }); + m.add({ type: 'default', message: `msg-${i}`, level: 'info' }); } - expect(m.getBreadcrumbs()).toHaveLength(15); + expect(m.get()).toHaveLength(15); }); it('should empty buffer on clear', () => { - const m = BreadcrumbManager.getInstance(); + const m = BrowserBreadcrumbStore.getInstance(); m.init(); - m.addBreadcrumb({ type: 'default', message: 'test', level: 'info' }); - m.clearBreadcrumbs(); + m.add({ type: 'default', message: 'test', level: 'info' }); + m.clear(); - expect(m.getBreadcrumbs()).toEqual([]); + expect(m.get()).toEqual([]); }); it('should return a copy, not the internal array', () => { - const m = BreadcrumbManager.getInstance(); + const m = BrowserBreadcrumbStore.getInstance(); m.init(); - m.addBreadcrumb({ type: 'default', message: 'test', level: 'info' }); + m.add({ type: 'default', message: 'test', level: 'info' }); - const first = m.getBreadcrumbs(); - const second = m.getBreadcrumbs(); + const first = m.get(); + const second = m.get(); expect(first).not.toBe(second); expect(first).toEqual(second); first.push({ type: 'default', message: 'injected', level: 'info', timestamp: 0 } as Breadcrumb); - expect(m.getBreadcrumbs()).toHaveLength(1); + expect(m.get()).toHaveLength(1); }); - it('should ignore second init call', () => { - const m = BreadcrumbManager.getInstance(); + it('should throw on second init call', () => { + const m = BrowserBreadcrumbStore.getInstance(); m.init({ maxBreadcrumbs: 5 }); - m.init({ maxBreadcrumbs: 100 }); + expect(() => { + m.init({ maxBreadcrumbs: 100 }); + }).toThrow('BrowserBreadcrumbStore is already initialized'); + + // sanity check: original config still applies for (let i = 0; i < 10; i++) { - m.addBreadcrumb({ type: 'default', message: `msg-${i}`, level: 'info' }); + m.add({ type: 'default', message: `msg-${i}`, level: 'info' }); } - expect(m.getBreadcrumbs()).toHaveLength(5); + expect(m.get()).toHaveLength(5); }); }); @@ -132,7 +136,7 @@ describe('beforeBreadcrumb', () => { it('should store modified breadcrumb when hook returns changed object', () => { // Arrange - const m = BreadcrumbManager.getInstance(); + const m = BrowserBreadcrumbStore.getInstance(); m.init({ beforeBreadcrumb(bc) { @@ -143,25 +147,25 @@ describe('beforeBreadcrumb', () => { }); // Act - m.addBreadcrumb({ type: 'default', message: 'original', level: 'info' }); + m.add({ type: 'default', message: 'original', level: 'info' }); // Assert - expect(m.getBreadcrumbs()[0].message).toBe('MODIFIED'); + expect(m.get()[0].message).toBe('MODIFIED'); }); it('should not store breadcrumb when hook returns false', () => { // Arrange - const m = BreadcrumbManager.getInstance(); + const m = BrowserBreadcrumbStore.getInstance(); m.init({ beforeBreadcrumb: () => false, }); // Act - m.addBreadcrumb({ type: 'default', message: 'drop', level: 'info' }); + m.add({ type: 'default', message: 'drop', level: 'info' }); // Assert - expect(m.getBreadcrumbs()).toHaveLength(0); + expect(m.get()).toHaveLength(0); }); it.each([ @@ -172,7 +176,7 @@ describe('beforeBreadcrumb', () => { { label: 'true', value: true }, ])('should store original breadcrumb and warn when hook returns $label', ({ value }) => { // Arrange - const m = BreadcrumbManager.getInstance(); + const m = BrowserBreadcrumbStore.getInstance(); m.init({ // eslint-disable-next-line @typescript-eslint/no-explicit-any @@ -180,10 +184,10 @@ describe('beforeBreadcrumb', () => { }); // Act - m.addBreadcrumb({ type: 'default', message: 'original', level: 'info' }); + m.add({ type: 'default', message: 'original', level: 'info' }); // Assert - expect(m.getBreadcrumbs()[0].message).toBe('original'); + expect(m.get()[0].message).toBe('original'); expect(logSpy).toHaveBeenCalledWith( expect.stringContaining('Invalid beforeBreadcrumb value'), 'warn' @@ -192,7 +196,7 @@ describe('beforeBreadcrumb', () => { it('should store original breadcrumb and warn when hook deletes required field (message)', () => { // Arrange - const m = BreadcrumbManager.getInstance(); + const m = BrowserBreadcrumbStore.getInstance(); m.init({ beforeBreadcrumb(bc) { @@ -204,15 +208,15 @@ describe('beforeBreadcrumb', () => { }); // Act - m.addBreadcrumb({ type: 'default', message: 'keep-me', level: 'info' }); + m.add({ type: 'default', message: 'keep-me', level: 'info' }); // Assert — fallback to original, message preserved - expect(m.getBreadcrumbs()[0].message).toBe('keep-me'); + expect(m.get()[0].message).toBe('keep-me'); }); it('should filter breadcrumbs by category using hook', () => { // Arrange - const m = BreadcrumbManager.getInstance(); + const m = BrowserBreadcrumbStore.getInstance(); m.init({ beforeBreadcrumb(bc) { @@ -221,11 +225,11 @@ describe('beforeBreadcrumb', () => { }); // Act - m.addBreadcrumb({ type: 'default', message: 'public', level: 'info', category: 'public' }); - m.addBreadcrumb({ type: 'default', message: 'secret', level: 'info', category: 'secret' }); + m.add({ type: 'default', message: 'public', level: 'info', category: 'public' }); + m.add({ type: 'default', message: 'secret', level: 'info', category: 'secret' }); // Assert - const crumbs = m.getBreadcrumbs(); + const crumbs = m.get(); expect(crumbs).toHaveLength(1); expect(crumbs[0].message).toBe('public'); diff --git a/packages/javascript/tests/catcher.addons.test.ts b/packages/javascript/tests/catcher.addons.test.ts index 09909361..42c23591 100644 --- a/packages/javascript/tests/catcher.addons.test.ts +++ b/packages/javascript/tests/catcher.addons.test.ts @@ -1,5 +1,5 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'; -import { BreadcrumbManager } from '../src/addons/breadcrumbs'; +import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs'; import { wait, createTransport, getLastPayload, createCatcher } from './catcher.helpers'; const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([])); @@ -12,7 +12,7 @@ describe('Catcher', () => { beforeEach(() => { localStorage.clear(); mockParse.mockResolvedValue([]); - (BreadcrumbManager as any).instance = null; + (BrowserBreadcrumbStore as any).instance?.destroy(); }); // ── Environment addons ──────────────────────────────────────────────────── diff --git a/packages/javascript/tests/catcher.breadcrumbs.test.ts b/packages/javascript/tests/catcher.breadcrumbs.test.ts index 8c065f6c..fe9a61cc 100644 --- a/packages/javascript/tests/catcher.breadcrumbs.test.ts +++ b/packages/javascript/tests/catcher.breadcrumbs.test.ts @@ -1,5 +1,5 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'; -import { BreadcrumbManager } from '../src/addons/breadcrumbs'; +import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs'; import { wait, createTransport, getLastPayload, createCatcher } from './catcher.helpers'; const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([])); @@ -12,7 +12,7 @@ describe('Catcher', () => { beforeEach(() => { localStorage.clear(); mockParse.mockResolvedValue([]); - (BreadcrumbManager as any).instance = null; + (BrowserBreadcrumbStore as any).instance?.destroy(); }); // ── Breadcrumbs trail ───────────────────────────────────────────────────── @@ -22,7 +22,7 @@ describe('Catcher', () => { describe('breadcrumbs trail', () => { it('should include recorded breadcrumbs', async () => { const { sendSpy, transport } = createTransport(); - const hawk = createCatcher(transport, { breadcrumbs: {} }); + const hawk = createCatcher(transport, { breadcrumbs: { trackFetch: false } }); hawk.breadcrumbs.add({ message: 'button clicked', timestamp: Date.now() }); hawk.send(new Error('e')); @@ -37,7 +37,7 @@ describe('Catcher', () => { it('should omit breadcrumbs when none have been recorded', async () => { const { sendSpy, transport } = createTransport(); - createCatcher(transport, { breadcrumbs: {} }).send(new Error('e')); + createCatcher(transport, { breadcrumbs: { trackFetch: false } }).send(new Error('e')); await wait(); expect(getLastPayload(sendSpy).breadcrumbs).toBeFalsy(); @@ -51,7 +51,7 @@ describe('Catcher', () => { it('should omit breadcrumbs cleared before payload was sent', async () => { const { sendSpy, transport } = createTransport(); - const hawk = createCatcher(transport, { breadcrumbs: {} }); + const hawk = createCatcher(transport, { breadcrumbs: { trackFetch: false } }); hawk.breadcrumbs.add({ message: 'click', timestamp: Date.now() }); hawk.breadcrumbs.clear(); diff --git a/packages/javascript/tests/catcher.context.test.ts b/packages/javascript/tests/catcher.context.test.ts index 062ef2bb..fe064a88 100644 --- a/packages/javascript/tests/catcher.context.test.ts +++ b/packages/javascript/tests/catcher.context.test.ts @@ -1,5 +1,5 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'; -import { BreadcrumbManager } from '../src/addons/breadcrumbs'; +import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs'; import { wait, createTransport, getLastPayload, createCatcher } from './catcher.helpers'; const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([])); @@ -12,7 +12,7 @@ describe('Catcher', () => { beforeEach(() => { localStorage.clear(); mockParse.mockResolvedValue([]); - (BreadcrumbManager as any).instance = null; + (BrowserBreadcrumbStore as any).instance?.destroy(); }); // ── Context enrichment ──────────────────────────────────────────────────── diff --git a/packages/javascript/tests/catcher.global-handlers.test.ts b/packages/javascript/tests/catcher.global-handlers.test.ts index e5936152..92cd19a8 100644 --- a/packages/javascript/tests/catcher.global-handlers.test.ts +++ b/packages/javascript/tests/catcher.global-handlers.test.ts @@ -1,6 +1,6 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; import Catcher from '../src/catcher'; -import { BreadcrumbManager } from '../src/addons/breadcrumbs'; +import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs'; import { TEST_TOKEN, wait, createTransport, getLastPayload } from './catcher.helpers'; const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([])); @@ -13,7 +13,7 @@ describe('Catcher', () => { beforeEach(() => { localStorage.clear(); mockParse.mockResolvedValue([]); - (BreadcrumbManager as any).instance = null; + (BrowserBreadcrumbStore as any).instance?.destroy(); }); // ── Global error handlers ───────────────────────────────────────────────── diff --git a/packages/javascript/tests/catcher.helpers.ts b/packages/javascript/tests/catcher.helpers.ts index 6a0ab21d..66599f1a 100644 --- a/packages/javascript/tests/catcher.helpers.ts +++ b/packages/javascript/tests/catcher.helpers.ts @@ -1,6 +1,7 @@ import { vi } from 'vitest'; import Catcher from '../src/catcher'; import type { Transport } from '../src'; +import type { MessageProcessor } from '@hawk.so/core'; export const TEST_TOKEN = 'eyJpbnRlZ3JhdGlvbklkIjoiOTU3MmQyOWQtNWJhZS00YmYyLTkwN2MtZDk5ZDg5MGIwOTVmIiwic2VjcmV0IjoiZTExODFiZWItMjdlMS00ZDViLWEwZmEtZmUwYTM1Mzg5OWMyIn0='; export const wait = (): Promise => new Promise((r) => setTimeout(r, 0)); @@ -19,6 +20,11 @@ export function getLastPayload(spy: ReturnType) { return calls[calls.length - 1][0].payload; } +export function injectProcessor(catcher: Catcher, processor: MessageProcessor<'errors/javascript'>): void { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + (catcher as any).messageProcessors.push(processor); +} + export function createCatcher(transport: Transport, options: Record = {}) { return new Catcher({ token: TEST_TOKEN, diff --git a/packages/javascript/tests/catcher.issues-config.test.ts b/packages/javascript/tests/catcher.issues-config.test.ts index a851878d..d0eb5699 100644 --- a/packages/javascript/tests/catcher.issues-config.test.ts +++ b/packages/javascript/tests/catcher.issues-config.test.ts @@ -1,5 +1,5 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; -import { BreadcrumbManager } from '../src/addons/breadcrumbs'; +import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs'; import type { HawkInitialSettings } from '../src/types'; import type { Transport } from '../src'; @@ -63,7 +63,7 @@ describe('Catcher issues config', () => { vi.restoreAllMocks(); localStorage.clear(); mockParse.mockResolvedValue([]); - (BreadcrumbManager as any).instance = null; + (BrowserBreadcrumbStore as any).instance = null; MockPerformanceObserver.reset(); vi.stubGlobal('PerformanceObserver', MockPerformanceObserver as unknown as typeof PerformanceObserver); }); diff --git a/packages/javascript/tests/catcher.message-processor.test.ts b/packages/javascript/tests/catcher.message-processor.test.ts new file mode 100644 index 00000000..031b4c83 --- /dev/null +++ b/packages/javascript/tests/catcher.message-processor.test.ts @@ -0,0 +1,63 @@ +import { describe, expect, it, vi } from 'vitest'; +import { createCatcher, createTransport, getLastPayload, injectProcessor, wait } from './catcher.helpers'; +import { MessageProcessor, ProcessingPayload } from '@hawk.so/core'; + +const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([])); +vi.mock('../src/modules/stackParser', () => ({ + default: class { + parse = mockParse; + } +})); + +describe('Catcher', () => { + describe('message processor', () => { + it('should send original message when processor does not modify it', async () => { + const { sendSpy, transport } = createTransport(); + const applySpy = vi.fn((payload: ProcessingPayload<'errors/javascript'>) => payload); + const processor: MessageProcessor<'errors/javascript'> = { apply: applySpy }; + const hawk = createCatcher(transport); + injectProcessor(hawk, processor); + + hawk.send('original message'); + await wait(); + + expect(applySpy).toHaveBeenCalledTimes(1); + expect(sendSpy).toHaveBeenCalledTimes(1); + expect(getLastPayload(sendSpy).title).toBe('original message'); + }); + + it('should send modified message when processor modify it', async () => { + const { sendSpy, transport } = createTransport(); + const applySpy = vi.fn((payload: ProcessingPayload<'errors/javascript'>) => { + return { + ...payload, + title: 'modified message', + }; + }); + const processor: MessageProcessor<'errors/javascript'> = { apply: applySpy }; + const hawk = createCatcher(transport); + injectProcessor(hawk, processor); + + hawk.send('original message'); + await wait(); + + expect(applySpy).toHaveBeenCalledTimes(1); + expect(sendSpy).toHaveBeenCalledTimes(1); + expect(getLastPayload(sendSpy).title).toBe('modified message'); + }); + + it('should drop message when processor returns null', async () => { + const { sendSpy, transport } = createTransport(); + const applySpy = vi.fn(() => null); + const processor: MessageProcessor<'errors/javascript'> = { apply: applySpy }; + const hawk = createCatcher(transport); + injectProcessor(hawk, processor); + + hawk.send('test error'); + await wait(); + + expect(applySpy).toHaveBeenCalledTimes(1); + expect(sendSpy).not.toHaveBeenCalled(); + }); + }); +}); diff --git a/packages/javascript/tests/catcher.test.ts b/packages/javascript/tests/catcher.test.ts index ffc918c4..372d57c5 100644 --- a/packages/javascript/tests/catcher.test.ts +++ b/packages/javascript/tests/catcher.test.ts @@ -1,7 +1,7 @@ -import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; import Catcher from '../src/catcher'; -import { BreadcrumbManager } from '../src/addons/breadcrumbs'; -import { TEST_TOKEN, wait, createTransport, getLastPayload, createCatcher } from './catcher.helpers'; +import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs'; +import { createCatcher, createTransport, getLastPayload, TEST_TOKEN, wait } from './catcher.helpers'; // StackParser is mocked to prevent real network calls to source files in the jsdom environment. const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([])); @@ -16,7 +16,7 @@ describe('Catcher', () => { beforeEach(() => { localStorage.clear(); mockParse.mockResolvedValue([]); - (BreadcrumbManager as any).instance = null; + (BrowserBreadcrumbStore as any).instance?.destroy(); }); // ── Constructor variants ────────────────────────────────────────────────── diff --git a/packages/javascript/tests/catcher.transport.test.ts b/packages/javascript/tests/catcher.transport.test.ts index 42f760b1..5f7d2f2b 100644 --- a/packages/javascript/tests/catcher.transport.test.ts +++ b/packages/javascript/tests/catcher.transport.test.ts @@ -1,5 +1,5 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'; -import { BreadcrumbManager } from '../src/addons/breadcrumbs'; +import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs'; import type { Transport } from '../src'; import { wait, createCatcher, createTransport } from './catcher.helpers'; @@ -13,7 +13,7 @@ describe('Catcher', () => { beforeEach(() => { localStorage.clear(); mockParse.mockResolvedValue([]); - (BreadcrumbManager as any).instance = null; + (BrowserBreadcrumbStore as any).instance?.destroy(); }); describe('transport failure', () => { diff --git a/packages/javascript/tests/catcher.user.test.ts b/packages/javascript/tests/catcher.user.test.ts index 5b63d79f..39003448 100644 --- a/packages/javascript/tests/catcher.user.test.ts +++ b/packages/javascript/tests/catcher.user.test.ts @@ -1,5 +1,5 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'; -import { BreadcrumbManager } from '../src/addons/breadcrumbs'; +import { BrowserBreadcrumbStore } from '../src/addons/breadcrumbs'; import { wait, createTransport, getLastPayload, createCatcher } from './catcher.helpers'; const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([])); @@ -12,7 +12,7 @@ describe('Catcher', () => { beforeEach(() => { localStorage.clear(); mockParse.mockResolvedValue([]); - (BreadcrumbManager as any).instance = null; + (BrowserBreadcrumbStore as any).instance?.destroy(); }); // ── User identity ───────────────────────────────────────────────────────── diff --git a/packages/javascript/tests/storages/hawk-local-storage.test.ts b/packages/javascript/tests/utils/hawk-local-storage.test.ts similarity index 96% rename from packages/javascript/tests/storages/hawk-local-storage.test.ts rename to packages/javascript/tests/utils/hawk-local-storage.test.ts index a9ea1e58..4ff52224 100644 --- a/packages/javascript/tests/storages/hawk-local-storage.test.ts +++ b/packages/javascript/tests/utils/hawk-local-storage.test.ts @@ -1,6 +1,6 @@ import type { Mock } from 'vitest'; import { beforeEach, afterEach, describe, it, expect, vi } from 'vitest'; -import { HawkLocalStorage } from '../../src/storages/hawk-local-storage'; +import { HawkLocalStorage } from '../../src/utils/hawk-local-storage'; describe('HawkLocalStorage', () => { let getItemSpy: Mock<(key: string) => string | null>; diff --git a/packages/javascript/tests/logger/logger.test.ts b/packages/javascript/tests/utils/logger.test.ts similarity index 97% rename from packages/javascript/tests/logger/logger.test.ts rename to packages/javascript/tests/utils/logger.test.ts index df4477bc..d20205b1 100644 --- a/packages/javascript/tests/logger/logger.test.ts +++ b/packages/javascript/tests/utils/logger.test.ts @@ -1,5 +1,5 @@ import { beforeEach, afterEach, describe, it, expect, vi } from 'vitest'; -import { createBrowserLogger } from '../../src/logger/logger'; +import { createBrowserLogger } from '../../src/utils/logger'; describe('createBrowserLogger', () => { let consoleLogSpy: ReturnType;