@blueking/open-telemetry 0.0.14 → 0.0.15

package/dist/core/action-activity.d.ts

@@ -0,0 +1,28 @@
+export type BkOTActivityEvent = {
+    endTime: number;
+    startTime: number;
+    type: 'long_task';
+    url?: never;
+} | {
+    endTime: number;
+    startTime: number;
+    type: 'resource';
+    url?: string;
+} | {
+    id: string;
+    time: number;
+    type: 'request_end';
+} | {
+    id: string;
+    time: number;
+    type: 'request_start';
+    url?: string;
+} | {
+    time: number;
+    type: 'dom_mutation' | 'error' | 'window_open';
+};
+export declare class RumActivityObserver {
+    private readonly listeners;
+    notify: (event: BkOTActivityEvent) => void;
+    subscribe: (listener: (event: BkOTActivityEvent) => void) => () => boolean;
+}

package/dist/core/config.d.ts

@@ -3,20 +3,18 @@ import type { BkOTBlankScreenPluginOptions } from '../plugins/blank-screen';
 import type { BkOTDevicePluginOptions } from '../plugins/device';
 import type { BkOTErrorPluginOptions } from '../plugins/error';
 import type { BkOTLongTaskPluginOptions } from '../plugins/long-task';
-import type { BkOTSessionPluginOptions } from '../plugins/session';
+import type { BkOTSessionConfig } from '../plugins/session';
 import type { BkOTPlugin } from './plugin';
 import type { BkOTUserContext } from './runtime-context';
 import type { Attributes } from '@opentelemetry/api';
 import type { Instrumentation } from '@opentelemetry/instrumentation';
 export interface BkOTActionEventPayload {
     attributes?: Attributes;
-    targetTag?: string;
-    targetText?: string;
-    type: 'click' | 'custom' | 'input' | 'keydown' | 'pointerdown' | 'scroll' | 'submit' | string;
+    name: string;
 }
-export interface BkOTAppConfig {
+export interface BkOTApplicationConfig {
     environment?: string;
-    name?: string;
+    name: string;
     version?: string;
 }
 export interface BkOTAttributesConfig {
@@ -32,125 +30,144 @@ export interface BkOTBatchConfig {
     maxQueueSize?: number;
     scheduledDelayMillis?: number;
 }
+export interface BkOTBeforeSendEvent {
+    attributes: Record<string, unknown>;
+    name: string;
+    signal: 'log' | 'span';
+}
+export interface BkOTContextConfig {
+    attributes?: BkOTAttributesConfig;
+    user?: BkOTUserContext;
+}
 export interface BkOTCustomEventPayload {
     attributes?: Attributes;
     error?: Error;
     name: string;
 }
-export interface BkOTHttpBodyConfig {
-    maxBodySize?: number;
-    redact?: (payload: BkOTHttpBodyRedactPayload) => string;
-}
-export interface BkOTHttpBodyRedactPayload {
-    body: string;
-    contentType?: string;
-    method: string;
-    status?: number;
-    truncated: boolean;
-    type: 'request' | 'response';
-    url: string;
-}
-export interface BkOTInstrumentationsConfig {
-    custom?: Instrumentation[];
-    documentLoad?: boolean;
-    fetch?: boolean;
-    /**
-     * 控制 fetch/xhr 请求向哪些后台 API 注入 W3C `traceparent`（内含 OpenTelemetry traceId）请求头。
-     *
-     * 同源请求始终注入；该配置用于把跨域后台 API 也纳入注入范围（在同源基础上扩展）：
-     * - `'all'`：所有请求都注入（含跨域，使用前确认涉及的隐私/CORS 影响）。
-     * - `string`：URL 包含该子串即注入，例如 `'api.example.com'`。
-     * - `RegExp`：URL 匹配该正则即注入。
-     * - 以上字符串/正则的数组：命中任意一个即注入。
-     * - `(url: string) => boolean`：完全自定义判断。
-     *
-     * 注意：向跨域服务注入自定义头会触发 CORS 预检，目标服务需在
-     * `Access-Control-Allow-Headers` 中放行 `traceparent`（以及按需的 `tracestate`）。
-     *
-     * 默认未配置时仅同源请求注入，保持既有行为。
-     */
-    propagateTraceHeaderUrls?: BkOTPropagateTraceHeaderUrls;
-    userInteraction?: boolean | {
-        eventNames?: string[];
-    };
-    xhr?: boolean;
+export interface BkOTExtensionsConfig {
+    instrumentations?: Instrumentation[];
+    plugins?: BkOTPlugin[];
 }
 export interface BkOTOptions {
-    app?: BkOTAppConfig;
-    attributes?: BkOTAttributesConfig;
+    application: BkOTApplicationConfig;
     autoStart?: boolean;
+    context?: BkOTContextConfig;
     debug?: boolean;
     enabled?: boolean;
-    instrumentations?: BkOTInstrumentationsConfig;
-    plugins?: BkOTPluginsConfig;
+    extensions?: BkOTExtensionsConfig;
     privacy?: BkOTPrivacyConfig;
-    route?: BkOTRouteConfig;
-    sampling?: BkOTSamplingConfig;
-    spanBatch?: BkOTBatchConfig;
-    spanProcessor?: BkOTSpanProcessorMode;
-    transport?: BkOTTransportConfig;
-    user?: BkOTUserContext;
+    session?: BkOTSessionConfig;
+    tracking?: BkOTTrackingConfig;
+    transport: BkOTTransportConfig;
+}
+export interface BkOTPrivacyConfig {
+    /** 初始化时的采集授权状态；运行期可通过 setTrackingConsent 更新。 */
+    trackingConsent?: BkOTTrackingConsent;
+    redactAttributes?: (attributes: Attributes) => Attributes;
+    redactUrl?: (url: string) => string;
 }
-export interface BkOTPluginsConfig {
+export interface BkOTRequestBodyConfig {
+    allowedContentTypes?: Array<RegExp | string>;
+    capture?: 'all' | 'errors';
+    maxSize?: number;
+    redact: (payload: BkOTRequestBodyRedactPayload) => string | undefined;
+}
+export interface BkOTRequestBodyRedactPayload {
+    body: string;
+    contentType?: string;
+    kind: 'request' | 'response';
+    method?: string;
+    statusCode?: number;
+    truncated: boolean;
+    type: 'fetch' | 'xhr';
+    url?: string;
+}
+export interface BkOTRequestConfig {
+    allowedTracingUrls?: BkOTUrlMatcher | BkOTUrlMatcher[];
+    body?: BkOTRequestBodyConfig;
+    excludedUrls?: BkOTUrlMatcher | BkOTUrlMatcher[];
+    beforeSend?: (event: BkOTRequestEvent, context: BkOTRequestContext) => boolean | void;
+}
+export type BkOTRequestContext = {
+    error?: unknown;
+    request: Request | RequestInit;
+    response?: Response;
+    type: 'fetch';
+} | {
+    requestBody?: Document | null | XMLHttpRequestBodyInit;
+    type: 'xhr';
+    xhr: XMLHttpRequest;
+};
+export interface BkOTRequestEvent {
+    attributes: Attributes;
+    type: 'resource';
+    resource: {
+        method?: string;
+        statusCode?: number;
+        type: 'fetch' | 'xhr';
+        url?: string;
+    };
+}
+export type BkOTSpanProcessorMode = 'batch' | 'simple';
+export interface BkOTTrackingConfig {
     action?: BkOTActionPluginOptions | boolean;
     blankScreen?: BkOTBlankScreenPluginOptions | boolean;
     cspViolation?: boolean;
-    custom?: BkOTPlugin[];
     device?: BkOTDevicePluginOptions | boolean;
     error?: BkOTErrorPluginOptions | boolean;
-    httpBody?: BkOTHttpBodyConfig | boolean;
     longTask?: BkOTLongTaskPluginOptions | boolean;
-    pageView?: boolean;
+    request?: BkOTRequestConfig | boolean;
     resource?: boolean;
-    routeTiming?: boolean;
-    session?: BkOTSessionPluginOptions | boolean;
+    view?: BkOTViewConfig;
     websocket?: boolean;
     webVitals?: boolean;
+    beforeSend?: (event: BkOTBeforeSendEvent) => boolean | void;
 }
-export interface BkOTPrivacyConfig {
-    redactAttributes?: (attributes: Attributes) => Attributes;
-    redactUrl?: (url: string) => string;
-}
-export type BkOTPropagateTraceHeaderUrls = 'all' | ((url: string) => boolean) | Array<RegExp | string> | RegExp | string;
-export interface BkOTRouteConfig {
-    /**
-     * 返回低基数路由分组，例如 `/trace/:id`。
-     * SDK 默认退化为 URL pathname；复杂业务路由建议接入方显式提供模板。
-     */
-    getPathGroup?: (url: string) => string | undefined;
-}
-export interface BkOTSamplingConfig {
-    rate?: number;
-}
-export type BkOTSpanProcessorMode = 'batch' | 'simple';
+export type BkOTTrackingConsent = 'granted' | 'not-granted';
 export interface BkOTTransportConfig {
     endpoint?: string;
     headers?: Record<string, string>;
     signals?: SignalExportersInputConfig;
     token?: string;
 }
-export interface ResolvedAppConfig {
+export type BkOTUrlMatcher = ((url: string) => boolean) | RegExp | string;
+export interface BkOTViewConfig {
+    /** 不参与 View loading time 的长轮询、流式请求或埋点 URL。 */
+    excludedActivityUrls?: BkOTUrlMatcher | BkOTUrlMatcher[];
+    /** 自动计算初始加载与 SPA 路由的页面稳定耗时，默认开启。 */
+    loadingTime?: boolean;
+    tracking?: 'auto' | 'manual';
+    /** 返回低基数路由分组，例如 `/trace/:id`。 */
+    getPathGroup?: (url: string) => string | undefined;
+}
+export interface MetricExporterInputConfig extends SignalExporterInputConfig {
+    intervalMillis?: number;
+}
+export interface ResolvedApplicationConfig {
     environment: string;
     name: string;
     version?: string;
 }
 export interface ResolvedBkOTConfig {
-    app: ResolvedAppConfig;
+    application: ResolvedApplicationConfig;
     autoStart: boolean;
     debug: boolean;
     enabled: boolean;
+    extensions: BkOTExtensionsConfig;
     hooks: ResolvedConfigHooks;
-    instrumentations: BkOTInstrumentationsConfig;
     metricIntervalMillis: number;
-    plugins: BkOTPluginsConfig;
     resourceAttributes: Attributes;
-    sampling: ResolvedSamplingConfig;
+    session: ResolvedSessionConfig;
     spanBatch?: BkOTBatchConfig;
     spanProcessor: BkOTSpanProcessorMode;
+    tracking: BkOTTrackingConfig;
+    trackingConsent: BkOTTrackingConsent;
     transport: ResolvedTransportConfig;
     user?: BkOTUserContext;
+    view: ResolvedViewConfig;
 }
 export interface ResolvedConfigHooks {
+    beforeSend?: (event: BkOTBeforeSendEvent) => boolean | void;
     getCustomAttributes: () => Attributes;
     getErrorAttributes: () => Attributes;
     getMetricAttributes: () => Attributes;
@@ -159,19 +176,19 @@ export interface ResolvedConfigHooks {
     redactAttributes: (attributes: Attributes) => Attributes;
     redactUrl: (url: string) => string;
 }
-export interface ResolvedSamplingConfig {
-    rate: number;
+export interface ResolvedSessionConfig extends BkOTSessionConfig {
+    sampleRate: number;
 }
 export interface ResolvedTransportConfig {
     endpoint: string;
-    logs: SignalExporterConfig;
-    metrics: SignalExporterConfig;
-    traces: SignalExporterConfig;
+    logs: false | SignalExporterConfig;
+    metrics: false | SignalExporterConfig;
+    traces: false | SignalExporterConfig;
 }
-export interface SignalEndpointsConfig {
-    logs?: string;
-    metrics?: string;
-    traces?: string;
+export interface ResolvedViewConfig {
+    excludedActivityUrls?: BkOTUrlMatcher | BkOTUrlMatcher[];
+    loadingTime: boolean;
+    tracking: 'auto' | 'manual';
 }
 export interface SignalExporterConfig {
     concurrencyLimit?: number;
@@ -181,9 +198,12 @@ export interface SignalExporterConfig {
 }
 export type SignalExporterInputConfig = Partial<SignalExporterConfig>;
 export interface SignalExportersInputConfig {
-    endpoints?: SignalEndpointsConfig;
-    logs?: SignalExporterInputConfig;
-    metrics?: SignalExporterInputConfig;
-    traces?: SignalExporterInputConfig;
+    logs?: false | SignalExporterInputConfig;
+    metrics?: false | MetricExporterInputConfig;
+    traces?: false | TraceExporterInputConfig;
+}
+export interface TraceExporterInputConfig extends SignalExporterInputConfig {
+    batch?: BkOTBatchConfig;
+    processor?: BkOTSpanProcessorMode;
 }
 export declare const resolveConfig: (config: BkOTOptions) => ResolvedBkOTConfig;

package/dist/core/page-activity.d.ts

@@ -0,0 +1,14 @@
+import type { BkOTRuntimeContext } from './plugin';
+export declare const PAGE_ACTIVITY_VALIDATION_DELAY = 100;
+export declare const PAGE_ACTIVITY_END_DELAY = 100;
+export type PageActivityEnd = {
+    endTime: number;
+    hadActivity: true;
+} | {
+    hadActivity: false;
+};
+/**
+ * 等待 View/Action 启动后的请求、静态资源和 DOM 变更全部安静 100ms。
+ * 请求用 id 精确配对，避免并发请求提前结束等待。
+ */
+export declare const waitForPageActivityEnd: (context: BkOTRuntimeContext, startTime: number, callback: (result: PageActivityEnd) => void) => () => void;

package/dist/core/plugin.d.ts

@@ -1,7 +1,9 @@
+import type { BkOTActivityEvent } from './action-activity';
 import type { ResolvedBkOTConfig } from './config';
-import type { BkOTUserContext, BkOTViewContext } from './runtime-context';
-import type { Attributes, Meter, Span, TimeInput, Tracer } from '@opentelemetry/api';
+import type { BkOTSessionLifecycleEvent, BkOTUserContext, BkOTViewCommand, BkOTViewContext } from './runtime-context';
+import type { Attributes, Meter, Span, SpanKind, TimeInput, Tracer } from '@opentelemetry/api';
 import type { Logger, LogRecord } from '@opentelemetry/api-logs';
+import type { Instrumentation } from '@opentelemetry/instrumentation';
 export interface BkOTPlugin {
     enabled?: ((config: ResolvedBkOTConfig) => boolean) | boolean;
     name: string;
@@ -18,25 +20,40 @@ export interface BkOTRuntimeContext {
     applyRedact: (attributes: Attributes) => Attributes;
     /** 包装 logger.emit，自动应用 redact 与 runtime attributes */
     emitLog: (record: LogRecord) => void;
+    flush: () => Promise<void>;
     getRuntimeAttributes: () => Attributes;
-    setRuntimeAttributes: (attributes: Attributes) => void;
+    getRuntimeAttributesAt: (timestamp: number) => Attributes;
+    isSampled: () => boolean;
+    isSessionActive: () => boolean;
+    isViewActive: () => boolean;
+    notifyActivity: (event: BkOTActivityEvent) => void;
+    notifySessionLifecycle: (event: BkOTSessionLifecycleEvent) => void;
+    onActivity: (listener: (event: BkOTActivityEvent) => void) => () => void;
+    onSessionLifecycle: (listener: (event: BkOTSessionLifecycleEvent) => void) => () => void;
+    onViewChange: (listener: (view: BkOTViewContext) => void) => () => void;
+    onViewCommand: (listener: (command: BkOTViewCommand) => void) => () => void;
+    registerInstrumentations: (instrumentations: Instrumentation[]) => void;
+    setRuntimeAttributes: (attributes: Attributes, changedAt?: number) => void;
     /** 更新用户上下文；user.id 由接入方传入，SDK 原样透传 */
     setUser: (user: BkOTUserContext) => void;
     /** 更新当前 View 上下文，后续 span/log 会自动带上 view.* 关联字段 */
-    setView: (view: BkOTViewContext) => void;
+    setView: (view: BkOTViewContext, changedAt?: number) => void;
     startSpan: (name: string, attributes?: Attributes, options?: BkOTStartSpanOptions) => Span;
 }
 /**
  * startSpan 的扩展选项。
  *
  * 用于"事件实际发生在过去某个时刻，但 span 现在才创建"的场景：
- * 例如 route-timing 在 raf+setTimeout 链路结束后才上报，但希望 span 的时间窗
- * 反映真实的"路由切换瞬间到渲染完成"区间，方便 trace 视图与并发请求对齐。
+ * 例如 PerformanceObserver 在条目结束后才回调，但 span 的时间窗仍需反映
+ * 条目真实发生的区间，方便 trace 视图与并发请求对齐。
  *
  * startTime 接受 OT TimeInput；常用 epoch 毫秒（performance.timeOrigin + performance.now()）。
  * 配合 span.end(endTime?) 可控制结束时间。
  */
 export interface BkOTStartSpanOptions {
+    /** 用于从历史中解析 Session/View/Action 归属；默认复用数字类型 startTime。 */
+    contextTime?: number;
+    kind?: SpanKind;
     startTime?: TimeInput;
 }
 export declare const isPluginEnabled: (plugin: BkOTPlugin, config: ResolvedBkOTConfig) => boolean;

package/dist/core/processor.d.ts

@@ -1,16 +1,37 @@
+import { AggregationTemporality } from '@opentelemetry/sdk-metrics';
 import type { ResolvedBkOTConfig } from './config';
-import type { Context } from '@opentelemetry/api';
+import type { Attributes, Context } from '@opentelemetry/api';
+import type { LogRecordProcessor, SdkLogRecord } from '@opentelemetry/sdk-logs';
+import type { InstrumentType, PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
 import type { ReadableSpan, Span, SpanProcessor } from '@opentelemetry/sdk-trace-base';
+export declare const REQUEST_DISCARD_ATTRIBUTE = "bk.rum.request.discard";
+export declare class FilteringLogRecordProcessor implements LogRecordProcessor {
+    private readonly inner;
+    private readonly config?;
+    constructor(inner: LogRecordProcessor, config?: ResolvedBkOTConfig | undefined);
+    enabled(options: Parameters<NonNullable<LogRecordProcessor['enabled']>>[0]): boolean;
+    forceFlush(): Promise<void>;
+    onEmit(logRecord: SdkLogRecord, context?: Context): void;
+    shutdown(): Promise<void>;
+}
 /**
- * 包装 SpanProcessor，在 onEnd 阶段过滤指向自身上报 endpoint 的 span，
- * 兜底防止 official fetch/xhr 拦截器对 OTel 自身请求产生回环 span。
+ * 给所有 span 固化创建时的运行时上下文，并在 onEnd 阶段过滤自身上报请求和无 RUM 上下文 span。
  */
 export declare class FilteringSpanProcessor implements SpanProcessor {
     private readonly inner;
     private readonly config;
-    constructor(inner: SpanProcessor, config: ResolvedBkOTConfig);
+    private readonly getRuntimeAttributes;
+    constructor(inner: SpanProcessor, config: ResolvedBkOTConfig, getRuntimeAttributes: () => Attributes);
     forceFlush(): Promise<void>;
     onEnd(span: ReadableSpan): void;
     onStart(span: Span, parentContext: Context): void;
     shutdown(): Promise<void>;
 }
+export declare class FilteringMetricExporter implements PushMetricExporter {
+    private readonly inner;
+    constructor(inner: PushMetricExporter);
+    export(metrics: ResourceMetrics, resultCallback: Parameters<PushMetricExporter['export']>[1]): void;
+    forceFlush(): Promise<void>;
+    selectAggregationTemporality(instrumentType: InstrumentType): AggregationTemporality;
+    shutdown(): Promise<void>;
+}

package/dist/core/request-timing.d.ts

@@ -0,0 +1,5 @@
+export declare const notifyRequestTiming: (entry: PerformanceResourceTiming) => void;
+export declare const trackRequestTiming: (url: string, startTime?: number) => {
+    cancel: () => void;
+    complete: (callback: (entry?: PerformanceResourceTiming) => void) => void;
+};

package/dist/core/runtime-context.d.ts

@@ -1,11 +1,41 @@
 import type { Attributes } from '@opentelemetry/api';
+export type BkOTSessionLifecycleEvent = {
+    expiredAt: number;
+    id: string;
+    reason: 'external' | 'inactivity' | 'maxLifetime';
+    type: 'expired';
+} | {
+    id: string;
+    previousId?: string;
+    reason: 'inactivity' | 'init' | 'maxLifetime' | 'shared';
+    startedAt: number;
+    type: 'renewed';
+};
+export interface BkOTStartViewOptions {
+    attributes?: Attributes;
+    name?: string;
+    url?: string;
+}
 export interface BkOTUserContext {
     /** 由接入方传入并由 SDK 原样透传；SDK 不 hash、不脱敏、不改写。 */
     id?: string;
 }
+export type BkOTViewCommand = {
+    name: string;
+    type: 'set_name';
+} | {
+    options: BkOTStartViewOptions;
+    type: 'start';
+} | {
+    time: number;
+    type: 'set_loading_time';
+};
 export interface BkOTViewContext {
+    attributes?: Attributes;
     id?: string;
-    loadingType?: 'initial_load' | 'route_change';
+    loadingType?: 'bf_cache' | 'initial_load' | 'route_change' | 'session_renewal';
+    name?: string;
+    startedAt?: number;
     url?: string;
     urlPathGroup?: string;
 }
@@ -16,15 +46,33 @@ export interface BkOTViewContext {
  * 插件发 span/log 时读取当前快照即可，避免每个插件重复维护公共字段。
  */
 export declare class RumRuntimeContext {
+    private readonly actionHistory;
     private readonly attributes;
+    private readonly queuedViewCommands;
+    private recordAssociation;
+    private readonly sessionHistory;
+    private readonly sessionLifecycleListeners;
     private readonly setOptionalAttribute;
     private user;
     private view;
+    private readonly viewAttributeKeys;
+    private readonly viewChangeListeners;
+    private readonly viewCommandListeners;
+    private readonly viewHistory;
+    private readonly viewScopedAttributeKeys;
+    dispatchViewCommand: (command: BkOTViewCommand) => void;
     getAttributes: () => Attributes;
+    getAttributesAt: (timestamp: number) => Attributes;
     getUser: () => BkOTUserContext;
     getView: () => BkOTViewContext;
-    setAttributes: (attributes: Attributes) => void;
+    isSessionActive: () => boolean;
+    isViewActive: () => boolean;
+    notifySessionLifecycle: (event: BkOTSessionLifecycleEvent) => void;
+    onSessionLifecycle: (listener: (event: BkOTSessionLifecycleEvent) => void) => () => boolean;
+    onViewChange: (listener: (view: BkOTViewContext) => void) => () => boolean;
+    onViewCommand: (listener: (command: BkOTViewCommand) => void) => () => boolean;
+    setAttributes: (attributes: Attributes, changedAt?: number) => void;
     setUser: (user: BkOTUserContext) => void;
-    setView: (view: BkOTViewContext) => void;
+    setView: (view: BkOTViewContext, changedAt?: number) => void;
     constructor(initialAttributes?: Attributes, user?: BkOTUserContext);
 }

package/dist/core/sampling.d.ts

@@ -1,2 +1,6 @@
 import type { ResolvedBkOTConfig } from './config';
-export declare const isBkOTSampled: ({ sampling }: Pick<ResolvedBkOTConfig, "sampling">) => boolean;
+export declare const RUM_SAMPLED_ATTRIBUTE = "bk.rum.sampled";
+/**
+ * 按应用和 RUM Session ID 做确定性采样。采样决定随 Session 更新，不再依赖 Tab 级 sessionStorage。
+ */
+export declare const isBkOTSampled: ({ application, session }: Pick<ResolvedBkOTConfig, "application" | "session">, sessionId: string) => boolean;

package/dist/core/sdk.d.ts

@@ -1,47 +1,66 @@
 import { type Attributes, type Span } from '@opentelemetry/api';
 import { type Instrumentation } from '@opentelemetry/instrumentation';
-import { type BkOTActionEventPayload, type BkOTCustomEventPayload, type BkOTOptions, type ResolvedBkOTConfig } from './config';
+import { type BkOTActionEventPayload, type BkOTCustomEventPayload, type BkOTOptions, type BkOTTrackingConsent, type ResolvedBkOTConfig } from './config';
 import { type BkOTPlugin, type BkOTRuntimeContext, type BkOTStartSpanOptions } from './plugin';
-import { type BkOTUserContext, type BkOTViewContext } from './runtime-context';
+import { type BkOTSessionLifecycleEvent, type BkOTStartViewOptions, type BkOTUserContext } from './runtime-context';
 import type { LogRecord } from '@opentelemetry/api-logs';
-export interface BkOTInstance extends BkOTRuntimeContext {
+export interface BkOTInstance extends Omit<BkOTRuntimeContext, 'notifyActivity' | 'onActivity' | 'onViewChange' | 'onViewCommand' | 'registerInstrumentations' | 'setView'> {
     flush: () => Promise<void>;
     reportAction: (payload: BkOTActionEventPayload) => void;
     reportCustomEvent: (payload: BkOTCustomEventPayload) => void;
+    setTrackingConsent: (consent: BkOTTrackingConsent) => Promise<void>;
     setUser: (user: BkOTUserContext) => void;
-    setView: (view: BkOTViewContext) => void;
+    setViewLoadingTime: () => void;
+    setViewName: (name: string) => void;
     shutdown: () => Promise<void>;
     start: () => Promise<void>;
+    startView: (options?: BkOTStartViewOptions) => void;
     use: (plugin: BkOTPlugin) => BkOTInstance;
     useInstrumentation: (instrumentation: Instrumentation) => BkOTInstance;
 }
 export declare class BkOpenTelemetry implements BkOTInstance {
+    private readonly activityObserver;
+    private readonly flushProviders;
     private readonly loggerProvider;
     private readonly meterProvider;
     private phase;
-    private readonly pluginManager;
-    private readonly plugins;
+    private pluginManager?;
     private readonly registeredInstrumentations;
+    private releaseOtelGlobals?;
     private readonly runtimeContext;
-    private readonly sampled;
+    private sampled;
+    private readonly startCollection;
+    private readonly stopCollection;
     private readonly teardownCallbacks;
     private readonly tracerProvider;
     private assertBeforeStart;
+    private createPluginContext;
+    private createPluginManager;
     readonly applyRedact: (attributes: Attributes) => Attributes;
     readonly config: ResolvedBkOTConfig;
     readonly emitLog: (record: LogRecord) => void;
     readonly flush: () => Promise<void>;
     readonly getRuntimeAttributes: () => Attributes;
+    readonly getRuntimeAttributesAt: (timestamp: number) => Attributes;
+    readonly isSampled: () => boolean;
+    readonly isSessionActive: () => boolean;
+    readonly isViewActive: () => boolean;
     readonly logger: BkOTRuntimeContext['logger'];
     readonly meter: BkOTRuntimeContext['meter'];
-    readonly reportAction: ({ attributes, targetTag, targetText, type }: BkOTActionEventPayload) => void;
+    readonly notifySessionLifecycle: (event: BkOTSessionLifecycleEvent) => void;
+    readonly onSessionLifecycle: (listener: (event: BkOTSessionLifecycleEvent) => void) => () => boolean;
+    readonly registerInstrumentations: (instrumentations: Instrumentation[]) => void;
+    readonly reportAction: ({ attributes, name }: BkOTActionEventPayload) => void;
     readonly reportCustomEvent: ({ attributes, error, name }: BkOTCustomEventPayload) => void;
-    readonly setRuntimeAttributes: (attributes: Attributes) => void;
+    readonly setRuntimeAttributes: (attributes: Attributes, changedAt?: number) => void;
+    readonly setTrackingConsent: (consent: BkOTTrackingConsent) => Promise<void>;
     readonly setUser: (user: BkOTUserContext) => void;
-    readonly setView: (view: BkOTViewContext) => void;
+    readonly setViewLoadingTime: () => void;
+    readonly setViewName: (name: string) => void;
     readonly shutdown: () => Promise<void>;
     readonly start: () => Promise<void>;
     readonly startSpan: (name: string, attributes?: Attributes, options?: BkOTStartSpanOptions) => Span;
+    readonly startView: (options?: BkOTStartViewOptions) => void;
     readonly tracer: BkOTRuntimeContext['tracer'];
     readonly use: (plugin: BkOTPlugin) => this;
     readonly useInstrumentation: (instrumentation: Instrumentation) => this;

package/dist/core/url.d.ts

@@ -1,4 +1,7 @@
-import type { ResolvedBkOTConfig } from './config';
+import type { BkOTUrlMatcher, ResolvedBkOTConfig } from './config';
+export declare const toAbsoluteUrl: (url: string) => string;
 export declare const isBkOTEndpoint: (config: ResolvedBkOTConfig, url: string) => boolean;
 export declare const shouldIgnoreUrl: (config: ResolvedBkOTConfig, url: string) => boolean;
+export declare const matchesUrlList: (matchers: BkOTUrlMatcher | BkOTUrlMatcher[] | undefined, url: string) => boolean;
+export declare const shouldIgnoreRequest: (config: ResolvedBkOTConfig, url: string) => boolean;
 export declare const shouldPropagateTraceHeader: (config: ResolvedBkOTConfig, url: string) => boolean;

package/dist/index.d.ts

@@ -1,21 +1,19 @@
-export { type BkOTActionEventPayload, type BkOTAppConfig, type BkOTAttributesConfig, type BkOTAttributeValue, type BkOTBatchConfig, type BkOTCustomEventPayload, type BkOTHttpBodyConfig, type BkOTHttpBodyRedactPayload, type BkOTInstrumentationsConfig, type BkOTOptions, type BkOTPluginsConfig, type BkOTPrivacyConfig, type BkOTPropagateTraceHeaderUrls, type BkOTSamplingConfig, type BkOTTransportConfig, resolveConfig, type ResolvedBkOTConfig, type ResolvedConfigHooks, type ResolvedTransportConfig, type SignalExporterConfig, type SignalExportersInputConfig, } from './core/config';
+export { type BkOTActionEventPayload, type BkOTApplicationConfig, type BkOTAttributesConfig, type BkOTAttributeValue, type BkOTBatchConfig, type BkOTBeforeSendEvent, type BkOTContextConfig, type BkOTCustomEventPayload, type BkOTExtensionsConfig, type BkOTOptions, type BkOTPrivacyConfig, type BkOTRequestBodyConfig, type BkOTRequestBodyRedactPayload, type BkOTRequestConfig, type BkOTRequestContext, type BkOTRequestEvent, type BkOTTrackingConfig, type BkOTTrackingConsent, type BkOTTransportConfig, type BkOTUrlMatcher, type BkOTViewConfig, type MetricExporterInputConfig, resolveConfig, type ResolvedApplicationConfig, type ResolvedBkOTConfig, type ResolvedConfigHooks, type ResolvedTransportConfig, type ResolvedViewConfig, type SignalExporterConfig, type SignalExportersInputConfig, type TraceExporterInputConfig, } from './core/config';
 export { type BkOTPlugin, type BkOTRuntimeContext, createPlugin, type PluginManager } from './core/plugin';
-export { FilteringSpanProcessor } from './core/processor';
-export { type BkOTUserContext, type BkOTViewContext, RumRuntimeContext } from './core/runtime-context';
+export { FilteringLogRecordProcessor, FilteringMetricExporter, FilteringSpanProcessor } from './core/processor';
+export { type BkOTSessionLifecycleEvent, type BkOTStartViewOptions, type BkOTUserContext, type BkOTViewContext, RumRuntimeContext, } from './core/runtime-context';
 export { BkOpenTelemetry, type BkOTInstance } from './core/sdk';
-export { RUM_ATTRIBUTES, type RumAttributeKey } from './schema/attributes';
-export { buildRumSpanAttributes, getDurationBucket, RUM_SPAN_RESULT, RUM_SPAN_TYPE, type RumSpanClassification, type RumSpanResult, type RumSpanType, } from './schema/span';
-export { createActionPlugin, type BkOTActionEventName, type BkOTActionPluginOptions } from './plugins/action';
-export { createBlankScreenPlugin, type BkOTBlankScreenPluginOptions } from './plugins/blank-screen';
+export { type BkOTActionPluginOptions, createActionPlugin } from './plugins/action';
+export { EXCLUDED_ACTIVITY_MUTATIONS_ATTRIBUTE } from './plugins/activity';
+export { type BkOTBlankScreenPluginOptions, createBlankScreenPlugin } from './plugins/blank-screen';
 export { createCommonInstrumentationsPlugin } from './plugins/common';
 export { createCspViolationPlugin } from './plugins/csp-violation';
-export { createDevicePlugin, type BkOTDevicePluginOptions } from './plugins/device';
-export { createErrorPlugin, type BkOTErrorPluginOptions } from './plugins/error';
-export { createHttpBodyPlugin } from './plugins/http-body';
-export { createLongTaskPlugin, type BkOTLongTaskPluginOptions } from './plugins/long-task';
-export { createPageViewPlugin } from './plugins/page-view';
+export { type BkOTDevicePluginOptions, createDevicePlugin } from './plugins/device';
+export { type BkOTErrorPluginOptions, createErrorPlugin } from './plugins/error';
+export { type BkOTLongTaskPluginOptions, createLongTaskPlugin } from './plugins/long-task';
 export { createResourcePlugin } from './plugins/resource';
-export { createRouteTimingPlugin } from './plugins/route-timing';
-export { createSessionPlugin, type BkOTSessionPluginOptions } from './plugins/session';
+export { type BkOTSessionConfig, createSessionPlugin } from './plugins/session';
 export { createWebVitalsPlugin } from './plugins/web-vitals';
 export { createWebSocketPlugin } from './plugins/websocket';
+export { RUM_ATTRIBUTES, type RumAttributeKey } from './schema/attributes';
+export { buildRumSpanAttributes, getDurationBucket, RUM_SPAN_RESULT, RUM_SPAN_TYPE, type RumSpanClassification, type RumSpanResult, type RumSpanType, } from './schema/span';