@sentry/core 10.50.0 → 10.52.0

package/build/types-ts3.8/integrations/http/types.d.ts

@@ -0,0 +1,252 @@
+/**
+ * Platform-portable HTTP(S) outgoing-request integration – type definitions.
+ *
+ * @module
+ *
+ * This Sentry integration is a derivative work based on the OpenTelemetry
+ * HTTP instrumentation.
+ *
+ * <https://github.com/open-telemetry/opentelemetry-js/tree/main/experimental/packages/opentelemetry-instrumentation-http>
+ *
+ * Extended under the terms of the Apache 2.0 license linked below:
+ *
+ * ----
+ *
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { RequestEventData } from '../../types-hoist/request';
+import { Span } from '../../types-hoist/span';
+/** Minimal interface for a Node.js http.ClientRequest */
+export interface HttpClientRequest {
+    method?: string;
+    path?: string;
+    host?: string;
+    protocol?: string;
+    port?: number;
+    end(): void;
+    getHeader(name: string): string | string[] | number | undefined;
+    getHeaders(): Record<string, string | string[] | undefined | number>;
+    setHeader(name: string, value: string | string[] | number): void;
+    removeHeader(name: string): void;
+    prependListener(event: 'response', listener: (res: HttpIncomingMessage) => void): this;
+    prependListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    once(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    listenerCount(event: string | symbol): number;
+    removeListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+}
+/** Minimal interface for http client RequestOptions */
+export interface HttpRequestOptions {
+    method?: string;
+    protocol?: string | null;
+    hostname?: string | null;
+    host?: string | null;
+    port?: string | number | null;
+    path?: string | null;
+    headers?: Record<string, string | string[] | undefined | number>;
+}
+/** Minimal interface for a Node.js http.ServerResponse */
+export interface HttpServerResponse {
+    statusCode: number;
+    statusMessage?: string;
+    headers: Record<string, string | undefined | string[] | number>;
+    once(ev: string, ...data: unknown[]): this;
+    once(ev: 'close'): this;
+    on(ev: string | symbol, handler: (...data: unknown[]) => void): this;
+}
+export interface HttpServer {
+    emit(ev: string, ...data: unknown[]): this;
+    emit(ev: 'request', request: HttpIncomingMessage, response: HttpServerResponse): this;
+}
+export interface HttpSocket {
+    remoteAddress?: string;
+    remotePort?: number;
+    localAddress?: string;
+    localPort?: number;
+}
+/** Minimal interface for a Node.js http.IncomingMessage */
+export interface HttpIncomingMessage {
+    statusCode?: number;
+    statusMessage?: string;
+    httpVersion?: string;
+    url?: string;
+    method?: string;
+    headers: Record<string, string | string[] | undefined>;
+    socket?: HttpSocket;
+    aborted?: boolean;
+    complete?: boolean;
+    resume(): void;
+    on(event: 'end', listener: () => void): this;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    addListener(event: 'end', listener: () => void): this;
+    addListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    off(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    removeListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+}
+/** Minimal interface for a Node.js http / https module export */
+export interface HttpExport {
+    request: (...args: any[]) => HttpClientRequest;
+    get: (...args: any[]) => HttpClientRequest;
+    [key: string]: unknown;
+}
+export type HttpModuleExport = HttpExport | (HttpExport & {
+    default: HttpExport;
+});
+export interface HttpInstrumentationOptions {
+    /**
+     * Whether to create spans for outgoing HTTP requests.
+     * @default true
+     */
+    spans?: boolean;
+    /**
+     * Whether to inject distributed trace propagation headers
+     * (`sentry-trace`, `baggage`, `traceparent`) into outgoing requests.
+     * @default false
+     */
+    propagateTrace?: boolean;
+    /**
+     * Skip span / breadcrumb creation for requests to matching URLs.
+     * Receives the full URL string and the outgoing request object.
+     */
+    ignoreOutgoingRequests?: (url: string, request: HttpClientRequest) => boolean;
+    /**
+     * Whether breadcrumbs should be recorded for outgoing requests.
+     * @default true
+     */
+    breadcrumbs?: boolean;
+    /**
+     * Called after the outgoing-request span is created by the client.
+     * Use this to add custom attributes to the span.
+     */
+    outgoingRequestHook?: (span: Span, request: HttpClientRequest) => void;
+    /**
+     * Called when the response is received by the client.
+     */
+    outgoingResponseHook?: (span: Span, response: HttpIncomingMessage) => void;
+    /**
+     * Called when both the request and response are available (after the
+     * response ends).  Useful for adding attributes based on both objects.
+     */
+    applyCustomAttributesOnSpan?: (span: Span, request: HttpClientRequest, response: HttpIncomingMessage) => void;
+    /**
+     * Symbol to use for observing errors on EventEmitters without consuming
+     * them.  Pass `EventEmitter.errorMonitor` from Node.js `events` module.
+     * Falls back to the plain `'error'` event string when not provided.
+     *
+     * Using the real `errorMonitor` symbol ensures that Sentry does not
+     * swallow errors before they reach user-supplied `'error'` handlers.
+     */
+    errorMonitor?: symbol | string;
+    /**
+     * Controls the maximum size of incoming HTTP request bodies attached to events.
+     *
+     * Available options:
+     * - 'none': No request bodies will be attached
+     * - 'small': Request bodies up to 1,000 bytes will be attached
+     * - 'medium': Request bodies up to 10,000 bytes will be attached (default)
+     * - 'always': Request bodies will always be attached
+     *
+     * Note that even with 'always' setting, bodies exceeding 1MB will never be attached
+     * for performance and security reasons.
+     *
+     * @default 'medium'
+     */
+    maxRequestBodySize?: 'none' | 'small' | 'medium' | 'always';
+    /**
+     * Do not capture the request body for incoming HTTP requests to URLs where the given callback returns `true`.
+     * This can be useful for long running requests where the body is not needed and we want to avoid capturing it.
+     *
+     * @param url Contains the entire URL, including query string (if any), protocol, host, etc. of the incoming request.
+     * @param request Contains the {@type RequestOptions} object used to make the incoming request.
+     */
+    ignoreRequestBody?: (url: string, request: HttpIncomingMessage) => boolean;
+    /**
+     * Whether the integration should create [Sessions](https://docs.sentry.io/product/releases/health/#sessions) for incoming requests to track the health and crash-free rate of your releases in Sentry.
+     * Read more about Release Health: https://docs.sentry.io/product/releases/health/
+     *
+     * Defaults to `true`.
+     */
+    sessions?: boolean;
+    /**
+     * Number of milliseconds until sessions tracked with `trackIncomingRequestsAsSessions` will be flushed as a session aggregate.
+     *
+     * Defaults to `60000` (60s).
+     */
+    sessionFlushingDelayMS?: number;
+    /**
+     * Optional callback that can be used by integrations to emit the 'request'
+     * event within a given Sentry or OTEL context, possibly after creating a
+     * span, as in the HttpServerSpansIntegration.
+     */
+    wrapServerEmitRequest?: (request: HttpIncomingMessage, response: HttpServerResponse, normalizedRequest: RequestEventData, next: () => void) => void;
+    /**
+     * Do not capture spans for incoming HTTP requests to URLs where the given callback returns `true`.
+     * Spans will be non recording if tracing is disabled.
+     *
+     * The `urlPath` param consists of the URL path and query string (if any) of the incoming request.
+     * For example: `'/users/details?id=123'`
+     *
+     * The `request` param contains the original {@type IncomingMessage} object of the incoming request.
+     * You can use it to filter on additional properties like method, headers, etc.
+     */
+    ignoreIncomingRequests?: (urlPath: string, request: HttpIncomingMessage) => boolean;
+    /**
+     * Whether to automatically ignore common static asset requests like favicon.ico, robots.txt, etc.
+     * This helps reduce noise in your transactions.
+     *
+     * @default `true`
+     */
+    ignoreStaticAssets?: boolean;
+    /**
+     * Do not capture spans for incoming HTTP requests with the given status codes.
+     * By default, spans with some 3xx and 4xx status codes are ignored (see @default).
+     * Expects an array of status codes or a range of status codes, e.g. [[300,399], 404] would ignore 3xx and 404 status codes.
+     *
+     * @default `[[401, 404], [301, 303], [305, 399]]`
+     */
+    ignoreStatusCodes?: (number | [
+        number,
+        number
+    ])[];
+    /**
+     * A hook that can be used to mutate the span for incoming requests.
+     * This is triggered after the span is created, but before it is recorded.
+     */
+    onSpanCreated?: (span: Span, request: HttpIncomingMessage, response: HttpServerResponse) => void;
+    /**
+     * A hook that can be used to mutate the span one last time when the
+     * response is finished, eg to update the transaction name based on
+     * the RPC metadata.
+     */
+    onSpanEnd?: (span: Span, request: HttpIncomingMessage, response: HttpServerResponse) => void;
+    /**
+     * Optional: pass in the `http` and `https` modules in order to detect
+     * whether a standalone OTel instrumentation is attempting to wrap them
+     * as well. This is fine, as long as `spans` option is disabled, but will
+     * result in double-emitting spans otherwise.
+     *
+     * Since this cannot be fully prevented due to module load timing, and isn't
+     * necessarily harmful per se (just noisy/annoying), and there are a number
+     * of reasonable approaches to fix it (disable the OTel instrumentation,
+     * disable this instrumentation, or keep both and disable spans in one or the
+     * other), we simply print a warning so the user can hopefully make an
+     * informed decision about how to address it (if at all).
+     */
+    http?: HttpModuleExport;
+    https?: HttpModuleExport;
+    /** suppress the warning about double-wrapping with OTel */
+    suppressOtelWarning?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/logs/envelope.d.ts

@@ -6,9 +6,11 @@ import { SdkMetadata } from '../types-hoist/sdkmetadata';
  * Creates a log container envelope item for a list of logs.
  *
  * @param items - The logs to include in the envelope.
+ * @param inferUserData - If true, tells Relay to infer the end-user IP and User-Agent from the incoming request.
+ *                        Only emitted as `ingest_settings` in browser environments.
  * @returns The created log container envelope item.
  */
-export declare function createLogContainerEnvelopeItem(items: Array<SerializedLog>): LogContainerItem;
+export declare function createLogContainerEnvelopeItem(items: Array<SerializedLog>, inferUserData?: boolean): LogContainerItem;
 /**
  * Creates an envelope for a list of logs.
  *
@@ -18,7 +20,8 @@ export declare function createLogContainerEnvelopeItem(items: Array<SerializedLo
  * @param metadata - The metadata to include in the envelope.
  * @param tunnel - The tunnel to include in the envelope.
  * @param dsn - The DSN to include in the envelope.
+ * @param inferUserData - If true, tells Relay to infer the end-user IP and User-Agent from the incoming request.
  * @returns The created envelope.
  */
-export declare function createLogEnvelope(logs: Array<SerializedLog>, metadata?: SdkMetadata, tunnel?: string, dsn?: DsnComponents): LogEnvelope;
+export declare function createLogEnvelope(logs: Array<SerializedLog>, metadata?: SdkMetadata, tunnel?: string, dsn?: DsnComponents, inferUserData?: boolean): LogEnvelope;
 //# sourceMappingURL=envelope.d.ts.map

package/build/types-ts3.8/metrics/envelope.d.ts

@@ -6,9 +6,11 @@ import { SdkMetadata } from '../types-hoist/sdkmetadata';
  * Creates a metric container envelope item for a list of metrics.
  *
  * @param items - The metrics to include in the envelope.
+ * @param inferUserData - If true, tells Relay to infer the end-user IP and User-Agent from the incoming request.
+ *                        Only emitted as `ingest_settings` in browser environments.
  * @returns The created metric container envelope item.
  */
-export declare function createMetricContainerEnvelopeItem(items: Array<SerializedMetric>): MetricContainerItem;
+export declare function createMetricContainerEnvelopeItem(items: Array<SerializedMetric>, inferUserData?: boolean): MetricContainerItem;
 /**
  * Creates an envelope for a list of metrics.
  *
@@ -18,7 +20,8 @@ export declare function createMetricContainerEnvelopeItem(items: Array<Serialize
  * @param metadata - The metadata to include in the envelope.
  * @param tunnel - The tunnel to include in the envelope.
  * @param dsn - The DSN to include in the envelope.
+ * @param inferUserData - If true, tells Relay to infer the end-user IP and User-Agent from the incoming request.
  * @returns The created envelope.
  */
-export declare function createMetricEnvelope(metrics: Array<SerializedMetric>, metadata?: SdkMetadata, tunnel?: string, dsn?: DsnComponents): MetricEnvelope;
+export declare function createMetricEnvelope(metrics: Array<SerializedMetric>, metadata?: SdkMetadata, tunnel?: string, dsn?: DsnComponents, inferUserData?: boolean): MetricEnvelope;
 //# sourceMappingURL=envelope.d.ts.map

package/build/types-ts3.8/server-runtime-client.d.ts

@@ -18,6 +18,7 @@ export interface ServerRuntimeClientOptions extends ClientOptions<BaseTransportO
  * The Sentry Server Runtime Client SDK.
  */
 export declare class ServerRuntimeClient<O extends ClientOptions & ServerRuntimeClientOptions = ServerRuntimeClientOptions> extends Client<O> {
+    private _disposeCallbacks;
     /**
      * Creates a new Edge SDK instance.
      * @param options Configuration options for this SDK.
@@ -47,6 +48,10 @@ export declare class ServerRuntimeClient<O extends ClientOptions & ServerRuntime
      * to create a monitor automatically when sending a check in.
      */
     captureCheckIn(checkIn: CheckIn, monitorConfig?: MonitorConfig, scope?: Scope): string;
+    /**
+     * @inheritDoc
+     */
+    registerCleanup(callback: () => void): void;
     /**
      * Disposes of the client and releases all resources.
      *

package/build/types-ts3.8/tracing/index.d.ts

@@ -5,7 +5,7 @@ export { SentrySpan } from './sentrySpan';
 export { SentryNonRecordingSpan } from './sentryNonRecordingSpan';
 export { setHttpStatus, getSpanStatusFromHttpCode } from './spanstatus';
 export { SPAN_STATUS_ERROR, SPAN_STATUS_OK, SPAN_STATUS_UNSET } from './spanstatus';
-export { startSpan, startInactiveSpan, startSpanManual, continueTrace, withActiveSpan, suppressTracing, startNewTrace, } from './trace';
+export { startSpan, startInactiveSpan, startSpanManual, continueTrace, withActiveSpan, suppressTracing, startNewTrace, SUPPRESS_TRACING_KEY, } from './trace';
 export { getDynamicSamplingContextFromClient, getDynamicSamplingContextFromSpan, getDynamicSamplingContextFromScope, spanToBaggageHeader, } from './dynamicSamplingContext';
 export { setMeasurement, timedEventsToMeasurements } from './measurement';
 export { sampleSpan } from './sampling';

package/build/types-ts3.8/tracing/langchain/types.d.ts

@@ -32,6 +32,14 @@ export interface LangChainSerialized {
     graph?: Record<string, unknown>;
     kwargs?: Record<string, unknown>;
 }
+/**
+ * Subset of the 'llm' param passed to createReactAgent
+ */
+export interface BaseChatModel {
+    lc_namespace: string[];
+    modelName?: string;
+    model?: string;
+}
 /**
  * LangChain message structure
  * Supports both regular messages and LangChain serialized format

package/build/types-ts3.8/tracing/langchain/utils.d.ts

@@ -57,4 +57,6 @@ export declare function extractChatModelRequestAttributes(llm: LangChainSerializ
  *   `stop_reason` (for providers that use it).
  */
 export declare function extractLlmResponseAttributes(llmResult: LangChainLLMResult, recordOutputs: boolean): Record<string, SpanAttributeValue> | undefined;
+export declare function getAgentNameFromMetadata(metadata?: Record<string, unknown>): Record<string, SpanAttributeValue>;
+export declare function extractToolDefinitions(extraParams?: Record<string, unknown>): string | undefined;
 //# sourceMappingURL=utils.d.ts.map

package/build/types-ts3.8/tracing/langgraph/index.d.ts

@@ -8,6 +8,10 @@ import { CompiledGraph, LangGraphOptions } from './types';
  *
  */
 export declare function instrumentStateGraphCompile(originalCompile: (...args: unknown[]) => CompiledGraph, options: LangGraphOptions): (...args: unknown[]) => CompiledGraph;
+/**
+ * Instruments createReactAgent to create invoke_agent and execute_tool spans.
+ */
+export declare function instrumentCreateReactAgent(originalCreateReactAgent: (...args: unknown[]) => CompiledGraph, options?: LangGraphOptions): (...args: unknown[]) => CompiledGraph;
 /**
  * Directly instruments a StateGraph instance to add tracing spans
  *

package/build/types-ts3.8/tracing/langgraph/utils.d.ts

@@ -1,6 +1,20 @@
 import { Span } from '../../types-hoist/span';
-import { LangChainMessage } from '../langchain/types';
-import { CompiledGraph } from './types';
+import { BaseChatModel, LangChainMessage } from '../langchain/types';
+import { CompiledGraph, LangGraphOptions } from './types';
+/**
+ * Extract LLM model object from createReactAgent params
+ */
+export declare function extractLLMFromParams(args: unknown[]): BaseChatModel | null;
+/**
+ * Extract agent name from createReactAgent params
+ */
+export declare function extractAgentNameFromParams(args: unknown[]): string | null;
+/**
+ * Wraps an array of LangChain tools so each invocation creates a gen_ai.execute_tool span.
+ *
+ * Wraps each tool's invoke() method in place. A marker prevents double-wrapping.
+ */
+export declare function wrapToolsWithSpans(tools: unknown[], options: LangGraphOptions, agentName?: string): unknown[];
 /**
  * Extract tool calls from messages
  */
@@ -28,4 +42,6 @@ export declare function extractToolsFromCompiledGraph(compiledGraph: CompiledGra
  * Set response attributes on the span
  */
 export declare function setResponseAttributes(span: Span, inputMessages: LangChainMessage[] | null, result: unknown): void;
+/** Merge `sentryHandler` into a langchain `callbacks` value (`BaseCallbackHandler[]` or `BaseCallbackManager`). */
+export declare function mergeSentryCallback(existing: unknown, sentryHandler: unknown): unknown;
 //# sourceMappingURL=utils.d.ts.map

package/build/types-ts3.8/tracing/spans/captureSpan.d.ts

@@ -14,13 +14,23 @@ export type SerializedStreamedSpanWithSegmentSpan = SerializedStreamedSpan & {
  * is needed later on to compute the DSC for the span envelope.
  */
 export declare function captureSpan(span: Span, client: Client): SerializedStreamedSpanWithSegmentSpan;
+/**
+ * Safely set attributes on a span JSON.
+ * If an attribute already exists, it will not be overwritten.
+ */
+export declare function safeSetSpanJSONAttributes(spanJSON: StreamedSpanJSON, newAttributes: RawAttributes<Record<string, unknown>>): void;
 /**
  * Apply a user-provided beforeSendSpan callback to a span JSON.
  */
 export declare function applyBeforeSendSpanCallback(span: StreamedSpanJSON, beforeSendSpan: (span: StreamedSpanJSON) => StreamedSpanJSON): StreamedSpanJSON;
 /**
- * Safely set attributes on a span JSON.
- * If an attribute already exists, it will not be overwritten.
+ * Infer and backfill span data from OTel semantic conventions.
+ * This mirrors what the `SentrySpanExporter` does for non-streamed spans via `getSpanData`/`inferSpanData`.
+ * Streamed spans skip the exporter, so we do the inference here during capture.
+ *
+ * Backfills: `sentry.op`, `sentry.source`, and `name` (description).
+ * Uses `safeSetSpanJSONAttributes` so explicitly set attributes are never overwritten.
  */
-export declare function safeSetSpanJSONAttributes(spanJSON: StreamedSpanJSON, newAttributes: RawAttributes<Record<string, unknown>>): void;
+/** Exported only for tests. */
+export declare function inferSpanDataFromOtelAttributes(spanJSON: StreamedSpanJSON, spanKind?: number): void;
 //# sourceMappingURL=captureSpan.d.ts.map

package/build/types-ts3.8/tracing/trace.d.ts

@@ -2,6 +2,7 @@ import { Scope } from '../scope';
 import { Span } from '../types-hoist/span';
 import { StartSpanOptions } from '../types-hoist/startSpanOptions';
 import { propagationContextFromHeaders } from '../utils/tracing';
+export declare const SUPPRESS_TRACING_KEY = "__SENTRY_SUPPRESS_TRACING__";
 /**
  * Wraps a function with a transaction/span and finishes the span after the function is done.
  * The created span is the active span and will be used as parent by other spans created inside the function

package/build/types-ts3.8/tracing/vercel-ai/constants.d.ts

@@ -1,5 +1,6 @@
 import { ToolCallSpanContext } from './types';
 export declare const toolCallSpanContextMap: Map<string, ToolCallSpanContext>;
+export declare const toolDescriptionMap: Map<string, Map<string, string>>;
 /** Maps Vercel AI span names to standardized OpenTelemetry operation names. */
 export declare const SPAN_TO_OPERATION_NAME: Map<string, string>;
 //# sourceMappingURL=constants.d.ts.map

package/build/types-ts3.8/tracing/vercel-ai/index.d.ts

@@ -1,4 +1,13 @@
 import { Client } from '../../client';
+/**
+ * Post-process spans emitted by the Vercel AI SDK.
+ */
+/**
+ * Rename and normalize Vercel AI SDK attributes to OpenTelemetry semantic conventions.
+ * This is the shared attribute processing logic used by both the legacy event processor
+ * path (SpanJSON) and the streamed span path (StreamedSpanJSON).
+ */
+export declare function processVercelAiSpanAttributes(attributes: Record<string, unknown>): void;
 /**
  * Add event processors to the given client to process Vercel AI spans.
  */

package/build/types-ts3.8/types-hoist/feedback/config.d.ts

@@ -159,6 +159,26 @@ export interface FeedbackTextConfiguration {
      * The label for the button that removed a highlight/hidden section of the screenshot.
      */
     removeHighlightText: string;
+    /**
+     * Error text shown when feedback submission is attempted with an empty message
+     */
+    errorEmptyMessageText: string;
+    /**
+     * Error text shown when the Sentry client is not set up
+     */
+    errorNoClientText: string;
+    /**
+     * Error text shown when the feedback submission times out (after 30s)
+     */
+    errorTimeoutText: string;
+    /**
+     * Error text shown when the feedback submission is blocked because the domain is not allowed (HTTP 403)
+     */
+    errorForbiddenText: string;
+    /**
+     * Error text shown when the feedback submission fails for any other reason (e.g. network error, ad-blocker)
+     */
+    errorGenericText: string;
 }
 /**
  * The public callbacks available for the feedback integration

package/build/types-ts3.8/types-hoist/feedback/index.d.ts

@@ -1,9 +1,9 @@
 import { Attachment } from '../attachment';
 import { Integration } from '../integration';
 import { FeedbackCallbacks, FeedbackGeneralConfiguration, FeedbackTextConfiguration, FeedbackThemeConfiguration } from './config';
-import { FeedbackEvent, SendFeedback, SendFeedbackParams, UserFeedback } from './sendFeedback';
+import { FeedbackErrorCode, FeedbackErrorMessages, FeedbackEvent, SendFeedback, SendFeedbackParams, UserFeedback } from './sendFeedback';
 export { FeedbackFormData } from './form';
-export { FeedbackEvent, UserFeedback, SendFeedback, SendFeedbackParams };
+export { FeedbackErrorCode, FeedbackErrorMessages, FeedbackEvent, SendFeedback, SendFeedbackParams, UserFeedback };
 /**
  * The integration's internal `options` member where every value should be set
  */

package/build/types-ts3.8/types-hoist/feedback/sendFeedback.d.ts

@@ -43,8 +43,11 @@ export interface SendFeedbackParams {
         [key: string]: Primitive;
     };
 }
+export type FeedbackErrorCode = 'ERROR_EMPTY_MESSAGE' | 'ERROR_NO_CLIENT' | 'ERROR_TIMEOUT' | 'ERROR_FORBIDDEN' | 'ERROR_GENERIC';
+export type FeedbackErrorMessages = Partial<Record<FeedbackErrorCode, string>>;
 export type SendFeedback = (params: SendFeedbackParams, hint?: EventHint & {
     includeReplay?: boolean;
+    errorMessages?: FeedbackErrorMessages;
 }) => Promise<string>;
 export {};
 //# sourceMappingURL=sendFeedback.d.ts.map

package/build/types-ts3.8/types-hoist/log.d.ts

@@ -52,6 +52,11 @@ export interface SerializedLog {
     severity_number?: Log['severityNumber'];
 }
 export type SerializedLogContainer = {
+    version?: number;
+    ingest_settings?: {
+        infer_ip?: 'auto' | 'never';
+        infer_user_agent?: 'auto' | 'never';
+    };
     items: Array<SerializedLog>;
 };
 //# sourceMappingURL=log.d.ts.map

package/build/types-ts3.8/types-hoist/metric.d.ts

@@ -61,6 +61,11 @@ export interface SerializedMetric {
     attributes?: Attributes;
 }
 export type SerializedMetricContainer = {
+    version?: number;
+    ingest_settings?: {
+        infer_ip?: 'auto' | 'never';
+        infer_user_agent?: 'auto' | 'never';
+    };
     items: Array<SerializedMetric>;
 };
 //# sourceMappingURL=metric.d.ts.map

package/build/types-ts3.8/types-hoist/options.d.ts

@@ -90,9 +90,16 @@ export interface ServerRuntimeOptions {
      */
     onFatalError?(this: void, error: Error): void;
 }
+/**
+ * Allowed attribute value matchers in `ignoreSpans` filters.
+ * String span attributes use pattern matching (substring or RegExp).
+ * Non-string attribute values match by strict equality (arrays element-wise).
+ */
+export type IgnoreSpanAttributeValue = string | boolean | number | string[] | boolean[] | number[] | RegExp;
 /**
  * A filter object for ignoring spans.
- * At least one of the properties (`op` or `name`) must be set.
+ * At least one of the properties (`name`, `op`, or `attributes`) must be set.
+ * If multiple are set, all must match for the span to be ignored.
  */
 type IgnoreSpanFilter = {
     /**
@@ -103,6 +110,12 @@ type IgnoreSpanFilter = {
      * Spans with an op matching this pattern will be ignored.
      */
     op?: string | RegExp;
+    /**
+     * Spans whose attributes ALL match the corresponding entries will be ignored.
+     * String attribute values are matched as patterns (substring or RegExp).
+     * Non-string values match by strict equality (arrays element-wise).
+     */
+    attributes?: Record<string, IgnoreSpanAttributeValue>;
 } | {
     /**
      * Spans with a name matching this pattern will be ignored.
@@ -112,6 +125,27 @@ type IgnoreSpanFilter = {
      * Spans with an op matching this pattern will be ignored.
      */
     op: string | RegExp;
+    /**
+     * Spans whose attributes ALL match the corresponding entries will be ignored.
+     * String attribute values are matched as patterns (substring or RegExp).
+     * Non-string values match by strict equality (arrays element-wise).
+     */
+    attributes?: Record<string, IgnoreSpanAttributeValue>;
+} | {
+    /**
+     * Spans with a name matching this pattern will be ignored.
+     */
+    name?: string | RegExp;
+    /**
+     * Spans with an op matching this pattern will be ignored.
+     */
+    op?: string | RegExp;
+    /**
+     * Spans whose attributes ALL match the corresponding entries will be ignored.
+     * String attribute values are matched as patterns (substring or RegExp).
+     * Non-string values match by strict equality (arrays element-wise).
+     */
+    attributes: Record<string, IgnoreSpanAttributeValue>;
 };
 export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOptions> {
     /**
@@ -291,7 +325,8 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
      * A list of span names or patterns to ignore.
      *
      * If you specify a pattern {@link IgnoreSpanFilter}, at least one
-     * of the properties (`op` or `name`) must be set.
+     * of the properties (`name`, `op`, or `attributes`) must be set.
+     * When multiple properties are set, all must match for the span to be ignored.
      *
      * @default []
      */

package/build/types-ts3.8/types-hoist/span.d.ts

@@ -50,6 +50,11 @@ export type SerializedStreamedSpan = Pick<StreamedSpanJSON, Exclude<keyof Stream
  * Envelope span item container.
  */
 export type SerializedStreamedSpanContainer = {
+    version?: number;
+    ingest_settings?: {
+        infer_ip?: 'auto' | 'never';
+        infer_user_agent?: 'auto' | 'never';
+    };
     items: Array<SerializedStreamedSpan>;
 };
 /** A JSON representation of a span. */

package/build/types-ts3.8/types-hoist/webfetchapi.d.ts

@@ -10,6 +10,8 @@ export interface WebFetchRequest {
     readonly headers: WebFetchHeaders;
     readonly method: string;
     readonly url: string;
+    readonly body?: unknown;
     clone(): WebFetchRequest;
+    text(): Promise<string>;
 }
 //# sourceMappingURL=webfetchapi.d.ts.map

package/build/types-ts3.8/utils/baggage.d.ts

@@ -37,4 +37,17 @@ export declare function parseBaggageHeader(baggageHeader: string | string[] | nu
  * is not spec compliant.
  */
 export declare function objectToBaggageHeader(object: Record<string, string>): string | undefined;
+/**
+ * Merge two baggage headers into one.
+ * - Sentry-specific entries (keys starting with "sentry-") from the new
+ *   baggage take precedence
+ * - Non-Sentry entries from existing baggage take precedence
+ *
+ * The order of the existing baggage will be preserved, and new entries will
+ * be added to the end.
+ *
+ * This matches the behavior of OTEL's propagation.inject() which uses
+ * `baggage.setEntry()`  to overwrite existing entries with the same key.
+ */
+export declare function mergeBaggageHeaders<Existing extends string | string[] | number | undefined>(existing: Existing, incoming: string): string | undefined | Existing;
 //# sourceMappingURL=baggage.d.ts.map