@coralogix/browser/src/types.d.ts

Official Coralogix SDK for browsers

import { Attributes, TextMapPropagator } from '@opentelemetry/api';
import { CoralogixDomainsApiUrlMap } from './constants';
import { CoralogixLogSeverity } from './types-external';
import { ErrorSource } from './instrumentations/CoralogixErrorInstrumentation';
import { FetchSource } from './instrumentations/network/CoralogixFetchInstrumentation';
import { XHRSource } from './instrumentations/network/CoralogixXhrInstrumentation';
import { LogSource } from './instrumentations/CoralogixCustomLogInstrumentation';
import { ReadableSpan } from '@opentelemetry/sdk-trace-base';
import { CoralogixUserInteractionInstrumentationConfig } from './instrumentations/user-interaction/CoralogixUserInteractionInstrumentation';
import { Metric } from 'web-vitals/attribution';
import { CoralogixWebVitalsInstrumentationConfig } from './instrumentations/instrumentation.model';
import { SessionConfig, SessionRecordingConfig } from './session/session.model';
import { CoralogixInternalEvent } from './instrumentations/CoralogixInternalInstrumentation';
import { SnapshotContext } from './snapshot/snapshot.model';
import { MetricWithAttribution } from 'web-vitals';
import { MemoryUsageContext } from './instrumentations/memory-usage';
import { MFEMetadata } from './mfe/mfe.types';
import { UrlBasedLabelProvider } from './label-providers/url-based-label-provider';
import { CustomTracer, CustomTracerIgnoredInstruments } from './custom-spans';
import { TraceExporterData } from './traces-exporter/traces-exporter.types';
export interface CxStackFrame extends Partial<MFEMetadata> {
    fileName?: string;
    columnNumber?: number;
    lineNumber?: number;
    functionName?: string;
    isShell?: boolean;
}
export interface GlobalTTIHandler {
    e: PerformanceEntryList;
    o?: PerformanceObserver;
}
export interface CoralogixWindow {
    __tti: GlobalTTIHandler;
    CoralogixRum: CoralogixOtelWebType;
}
export declare enum CoralogixEventType {
    ERROR = "error",
    NETWORK_REQUEST = "network-request",
    LOG = "log",
    USER_INTERACTION = "user-interaction",
    WEB_VITALS = "web-vitals",
    LONG_TASK = "longtask",
    RESOURCES = "resources",
    INTERNAL = "internal",
    DOM = "dom",
    CUSTOM_MEASUREMENT = "custom-measurement",
    MEMORY_USAGE = "memory-usage",
    SCREENSHOT = "screenshot",
    CUSTOM_SPAN = "custom-span",
    WORKER = "web-worker"
}
export declare enum PerformanceTypes {
    Resource = "resource",
    LongTask = "longtask",
    Navigation = "navigation",
    SoftNavigation = "soft-navigation"
}
export type CustomMeasurementData = number;
export type WebVitalsRating = 'good' | 'needs-improvement' | 'poor';
export type CoralogixDomain = keyof typeof CoralogixDomainsApiUrlMap;
export type CoralogixRumLabels = Record<string, any>;
export interface UserContextConfig {
    user_id: string;
    user_name: string;
    user_email?: string;
    user_metadata?: {
        [key: string]: any;
    };
}
export interface CustomTargetElement extends HTMLElement {
    type: string;
    value: string;
}
export interface ScreenshotContext {
    id: string;
    description?: string;
}
export interface ApplicationContextConfig {
    application: string;
    version: string;
}
export interface TraceHeaderConfiguration {
    enabled: boolean;
    options?: {
        propagateTraceHeaderCorsUrls?: Array<string | RegExp>;
        allowedTracingUrls?: Array<string | RegExp>;
        propagateAwsXrayTraceHeader?: boolean;
        propagateB3TraceHeader?: {
            singleHeader?: boolean;
            multiHeader?: boolean;
        };
        propagateCustomTraceHeader?: TextMapPropagator;
    };
}
export interface CoralogixOtelWebOptionsInstrumentations {
    errors?: boolean;
    fetch?: boolean;
    xhr?: boolean;
    custom?: boolean;
    long_tasks?: boolean;
    resources?: boolean;
    interactions?: boolean | CoralogixUserInteractionInstrumentationConfig;
    web_vitals?: boolean | CoralogixWebVitalsInstrumentationConfig;
}
interface SendLog {
    log: (severity: CoralogixLogSeverity, message: string, data?: any, labels?: CoralogixRumLabels) => void;
    debug: (message: string, data?: any, labels?: CoralogixRumLabels) => void;
    verbose: (message: string, data?: any, labels?: CoralogixRumLabels) => void;
    info: (message: string, data?: any, labels?: CoralogixRumLabels) => void;
    warn: (message: string, data?: any, labels?: CoralogixRumLabels) => void;
    error: (message: string, data?: any, labels?: CoralogixRumLabels) => void;
    critical: (message: string, data?: any, labels?: CoralogixRumLabels) => void;
}
export type UrlBlueprinter = (url: string) => string;
export interface UrlBlueprinters {
    pageUrlBlueprinters?: UrlBlueprinter[];
    networkUrlBlueprinters?: UrlBlueprinter[];
}
export interface MemoryUsageConfig {
    enabled: boolean;
    interval?: number;
}
export type BeforeSendResult = EditableCxRumEvent | null | undefined;
export interface NetworkExtraConfig {
    url: string | RegExp;
    reqHeaders?: string[];
    resHeaders?: string[];
    collectReqPayload?: boolean;
    collectResPayload?: boolean;
}
export interface CoralogixBrowserSdkConfig {
    public_key?: string;
    application: string;
    coralogixDomain: CoralogixDomain;
    version: string;
    user_context?: UserContextConfig;
    debug?: boolean;
    labels?: CoralogixRumLabels;
    ignoreUrls?: Array<string | RegExp>;
    ignoreErrors?: Array<string | RegExp>;
    instrumentations?: CoralogixOtelWebOptionsInstrumentations;
    traceParentInHeader?: TraceHeaderConfiguration;
    environment?: string;
    stringifyCustomLogData?: boolean;
    urlBlueprinters?: UrlBlueprinters;
    sessionRecordingConfig?: SessionRecordingConfig;
    sessionConfig?: SessionConfig;
    labelProviders?: Array<LabelProvider>;
    sessionSampleRate?: number;
    maskInputTypes?: InputType[];
    maskClass?: string | RegExp;
    beforeSend?: (event: EditableCxRumEvent) => BeforeSendResult;
    proxyUrl?: string;
    ignoreProxyUrlParams?: boolean;
    collectIPData?: boolean;
    trackSoftNavigations?: boolean;
    memoryUsageConfig?: MemoryUsageConfig;
    networkExtraConfig?: NetworkExtraConfig[];
    supportMfe?: boolean;
    workerSupport?: boolean;
    tracesExporter?: (data: TraceExporterData) => void;
}
export interface CoralogixOtelWebType extends SendLog {
    init: (options: CoralogixBrowserSdkConfig) => void;
    shutdown: () => void;
    setLabels: (labels: CoralogixRumLabels) => void;
    getLabels: () => CoralogixRumLabels;
    setUserContext: (userContext: UserContextConfig) => void;
    setApplicationContext: (applicationContext: ApplicationContextConfig) => void;
    captureError: (error: Error, customData?: unknown, labels?: CoralogixRumLabels) => void;
    sendCustomMeasurement: (name: string, value: CustomMeasurementData) => void;
    addTiming: (name: string, duration?: number) => void;
    measureUserAgentSpecificMemory: () => void;
    getUserContext: () => UserContextConfig | undefined;
    getSessionId: () => string | undefined;
    stopSessionRecording: () => void;
    startSessionRecording: () => void;
    screenshot: (description?: string) => string | undefined;
    startTimeMeasure: (name: string, labels?: CoralogixRumLabels) => void;
    endTimeMeasure: (name: string) => void;
    getCustomTracer: (ignoredList?: {
        ignoredInstruments: CustomTracerIgnoredInstruments[];
    }) => CustomTracer | undefined;
    readonly isInited: boolean;
}
export interface ErrorContext {
    error_type?: string;
    error_message?: string;
    error_custom_data?: unknown;
    original_stacktrace?: CxStackFrame[];
}
export interface LogContext {
    message: string;
    data?: any;
}
export interface InternalContext {
    event: CoralogixInternalEvent;
    data?: any;
}
export interface NetworkRequestContext {
    method: string;
    status_code: number;
    url: string;
    url_blueprint: string;
    fragments: string;
    host: string;
    schema: string;
    status_text: string;
    response_content_length: string;
    duration: number;
    source: EventSource;
    request_headers?: Map<string, string>;
    response_headers?: Map<string, string>;
    response_payload?: string;
    request_payload?: string;
}
export interface InteractionContext {
    target_element: string;
    target_element_inner_text: string;
    target_element_type: string;
    event_name: string;
    element_id: string;
    element_classes: string;
}
export interface LongTaskContext extends Omit<PerformanceEntry, 'toJSON'> {
    id: string;
}
export interface WebVitalsContext extends Metric {
    attribution?: MetricWithAttribution;
}
export interface ResourceContext extends Omit<PerformanceResourceTiming, 'toJSON'> {
    responseStatus?: number;
    deliveryType?: string;
    firstInterimResponseStart?: number;
    renderBlockingStatus?: string;
    fragments: string;
}
export interface CustomMeasurementContext {
    name: string;
    value: CustomMeasurementData;
}
export interface EventTypeContext {
    error_context?: ErrorContext;
    log_context?: LogContext;
    internal_context?: InternalContext;
    network_request_context?: NetworkRequestContext;
    interaction_context?: InteractionContext;
    web_vitals_context?: WebVitalsContext;
    longtask_context?: LongTaskContext;
    resource_context?: ResourceContext;
    snapshot_context?: SnapshotContext;
    custom_measurement_context?: CustomMeasurementContext;
    screenshot_context?: ScreenshotContext;
    memory_usage_context?: MemoryUsageContext;
}
export interface UserMetadata {
    user_id: string;
    user_name?: string;
    user_email?: string;
    user_metadata?: {
        [key: string]: any;
    };
}
export interface SessionContext extends UserMetadata {
    session_id: string;
    session_creation_date: number;
    prev_session?: {
        session_id: string;
        session_creation_date: number;
        hasRecording: boolean;
        hasScreenshot: boolean;
    };
    user_agent: string;
    browser?: Browser;
    browserVersion: string;
    os: OS;
    osVersion: string;
    device: Device;
    hasRecording: boolean;
    hasScreenshot: boolean;
    hasError?: boolean;
    onlyWithErrorMode: boolean;
}
export type EventSource = ErrorSource | FetchSource | XHRSource | LogSource;
export interface EventContext {
    type: CoralogixEventType;
    source: EventSource;
    severity: CoralogixLogSeverity;
}
interface SpanContext {
    readonly spanId: string;
    readonly traceId: string;
    sessionId: string;
}
interface OtelResource {
    attributes: Attributes;
}
interface InstrumentationData {
    otelSpan: Partial<ReadableSpan> & SpanContext;
    otelResource: OtelResource;
}
interface VersionMetaData {
    app_name: string;
    app_version: string;
}
export interface PageContext {
    page_url: string;
    page_url_blueprint: string;
    page_fragments: string;
    referrer: string;
}
export interface CxRumEvent extends EventTypeContext {
    browser_sdk: {
        version: string;
    };
    platform: 'browser';
    version_metadata: VersionMetaData;
    session_context: SessionContext;
    page_context: PageContext;
    event_context: EventContext;
    isNavigationEvent: boolean;
    labels: CoralogixRumLabels;
    spanId?: string;
    traceId?: string;
    parentSpanId?: string;
    environment: string;
    timestamp: number;
    isSnapshotEvent?: boolean;
    screenshot_context?: ScreenshotContext;
    screenshotId?: string;
    fingerPrint: string;
}
export interface CxSpan {
    version_metadata: VersionMetaData;
    applicationName: string;
    subsystemName: string;
    timestamp: number;
    severity: CoralogixLogSeverity;
    isErrorWithStacktrace: boolean;
    instrumentation_data?: InstrumentationData;
    text: {
        cx_rum: CxRumEvent;
    };
}
export interface Session {
    sessionId: string;
    sessionCreationDate: number;
    sessionExpirationDate: number;
}
export interface PrevSession extends Session {
    hasRecording: boolean;
    hasScreenshot: boolean;
}
export declare enum OtelNetworkAttrs {
    METHOD = "http.method",
    URL = "http.url",
    STATUS_CODE = "http.status_code",
    HOST = "http.host",
    SCHEME = "http.scheme",
    STATUS_TEXT = "http.status_text",
    RESPONSE_CONTENT_LENGTH = "http.response_content_length"
}
export type Browser = 'Chrome' | 'Edge' | 'Firefox' | 'Safari' | 'Opera' | 'IE' | 'Unknown';
export type OS = 'Windows' | 'MacOS' | 'Linux' | 'iOS' | 'Android' | 'Tizen' | 'webOS' | 'Unknown';
export type Device = 'Mobile' | 'Tablet' | 'Desktop' | 'Smart-TV' | 'Unknown';
export type UserAgentData = {
    browser: Browser;
    browserVersion: string;
    os: OS;
    osVersion: string;
    device: Device;
};
export type EventName = keyof HTMLElementEventMap;
export interface PatternReplacement {
    pattern: RegExp;
    replacement: string;
}
export declare enum UrlType {
    PAGE = "page",
    NETWORK_REQUEST = "network_request"
}
export type LabelProviderLabels = Record<string, string | undefined>;
export interface GenericLabelProvider {
    urlType?: UrlType;
    providerFunc: (url: string, event: CxRumEvent) => LabelProviderLabels;
}
export type LabelProvider = UrlBasedLabelProvider | GenericLabelProvider;
export type InputType = 'button' | 'checkbox' | 'color' | 'date' | 'datetime-local' | 'email' | 'file' | 'hidden' | 'image' | 'month' | 'number' | 'password' | 'radio' | 'range' | 'reset' | 'search' | 'submit' | 'tel' | 'text' | 'time' | 'url' | 'week';
export interface EditableCxRumEvent extends Omit<CxRumEvent, 'session_context' | 'browser_sdk' | 'timestamp'> {
    session_context: Pick<SessionContext, keyof UserMetadata>;
}
interface BrowserCompatibility {
    name: Browser;
    minVersion: number;
}
export interface InstrumentationCompatibility {
    browsers: BrowserCompatibility[];
    warningText: string;
}
export {};