@sentry/node 7.99.0 → 7.100.0

package/types-ts3.8/integrations/contextlines.d.ts

@@ -4,10 +4,25 @@ import { Event, Integration, IntegrationClass } from '@sentry/types';
  * @hidden
  */
 export declare function resetFileContentCache(): void;
-/** Add node modules / packages to the event */
+interface ContextLinesOptions {
+    /**
+     * Sets the number of context lines for each frame when loading a file.
+     * Defaults to 7.
+     *
+     * Set to 0 to disable loading and inclusion of source files.
+     **/
+    frameContextLines?: number;
+}
+export declare const contextLinesIntegration: (options?: ContextLinesOptions | undefined) => import("@sentry/types").IntegrationFnResult;
+/**
+ * Add node modules / packages to the event.
+ * @deprecated Use `contextLinesIntegration()` instead.
+ */
 export declare const ContextLines: IntegrationClass<Integration & {
     processEvent: (event: Event) => Promise<Event>;
 }> & (new (options?: {
     frameContextLines?: number;
 }) => Integration);
+export type ContextLines = typeof ContextLines;
+export {};
 //# sourceMappingURL=contextlines.d.ts.map

package/types-ts3.8/integrations/hapi/index.d.ts

@@ -12,8 +12,11 @@ export type HapiOptions = {
     /** Hapi server instance */
     server?: Record<any, any>;
 };
+export declare const hapiIntegration: (options?: HapiOptions | undefined) => import("@sentry/types").IntegrationFnResult;
 /**
- * Hapi Framework Integration
+ * Hapi Framework Integration.
+ * @deprecated Use `hapiIntegration()` instead.
  */
 export declare const Hapi: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration>;
+export type Hapi = typeof Hapi;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,5 +1,6 @@
 import { Hub } from '@sentry/core';
-import { EventProcessor, Integration, TracePropagationTargets } from '@sentry/types';
+import { ClientOptions, EventProcessor, Integration, IntegrationFnResult, TracePropagationTargets } from '@sentry/types';
+import { NodeClientOptions } from '../types';
 interface TracingOptions {
     /**
      * List of strings/regex controlling to which outgoing requests
@@ -24,6 +25,11 @@ interface TracingOptions {
      * By default, spans will be created for all outgoing requests.
      */
     shouldCreateSpanForRequest?: (url: string) => boolean;
+    /**
+     * This option is just for compatibility with v7.
+     * In v8, this will be the default behavior.
+     */
+    enableIfHasTracingEnabled?: boolean;
 }
 interface HttpOptions {
     /**
@@ -37,9 +43,35 @@ interface HttpOptions {
      */
     tracing?: TracingOptions | boolean;
 }
+interface HttpIntegrationOptions {
+    /**
+     * Whether breadcrumbs should be recorded for requests
+     * Defaults to true.
+     */
+    breadcrumbs?: boolean;
+    /**
+     * Whether tracing spans should be created for requests
+     * If not set, this will be enabled/disabled based on if tracing is enabled.
+     */
+    tracing?: boolean;
+    /**
+     * Function determining whether or not to create spans to track outgoing requests to the given URL.
+     * By default, spans will be created for all outgoing requests.
+     */
+    shouldCreateSpanForRequest?: (url: string) => boolean;
+}
+/**
+ * The http module integration instruments Node's internal http module. It creates breadcrumbs, spans for outgoing
+ * http requests, and attaches trace data when tracing is enabled via its `tracing` option.
+ *
+ * By default, this will always create breadcrumbs, and will create spans if tracing is enabled.
+ */
+export declare const httpIntegration: (options?: HttpIntegrationOptions | undefined) => IntegrationFnResult;
 /**
  * The http module integration instruments Node's internal http module. It creates breadcrumbs, transactions for outgoing
  * http requests and attaches trace data when tracing is enabled via its `tracing` option.
+ *
+ * @deprecated Use `httpIntegration()` instead.
  */
 export declare class Http implements Integration {
     /**
@@ -61,5 +93,9 @@ export declare class Http implements Integration {
      */
     setupOnce(_addGlobalEventProcessor: (callback: EventProcessor) => void, setupOnceGetCurrentHub: () => Hub): void;
 }
+/** Exported for tests only. */
+export declare function _shouldCreateSpans(tracingOptions: TracingOptions | undefined, clientOptions: Partial<ClientOptions> | undefined): boolean;
+/** Exported for tests only. */
+export declare function _getShouldCreateSpanForRequest(shouldCreateSpans: boolean, tracingOptions: TracingOptions | undefined, clientOptions: Partial<NodeClientOptions> | undefined): undefined | ((url: string) => boolean);
 export {};
 //# sourceMappingURL=http.d.ts.map

package/types-ts3.8/integrations/local-variables/index.d.ts

@@ -1,8 +1,13 @@
+import { LocalVariablesSync } from './local-variables-sync';
 /**
- * Adds local variables to exception frames
+ * Adds local variables to exception frames.
+ *
+ * @deprecated Use `localVariablesIntegration()` instead.
  */
 export declare const LocalVariables: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
     processEvent: (event: import("@sentry/types").Event) => import("@sentry/types").Event;
     setup: (client: import("../..").NodeClient) => void;
 }> & (new (options?: import("./common").LocalVariablesIntegrationOptions | undefined, session?: import("./local-variables-sync").DebugSession | undefined) => import("@sentry/types").Integration);
+export type LocalVariables = LocalVariablesSync;
+export declare const localVariablesIntegration: (options?: import("./common").LocalVariablesIntegrationOptions | undefined, session?: import("./local-variables-sync").DebugSession | undefined) => import("@sentry/types").IntegrationFnResult;
 //# sourceMappingURL=index.d.ts.map

package/types-ts3.8/integrations/local-variables/local-variables-async.d.ts

@@ -1,10 +1,14 @@
 import { Event, Integration, IntegrationClass } from '@sentry/types';
 import { NodeClient } from '../../client';
+import { LocalVariablesIntegrationOptions } from './common';
+export declare const localVariablesAsyncIntegration: (options?: LocalVariablesIntegrationOptions | undefined) => import("@sentry/types").IntegrationFnResult;
 /**
- * Adds local variables to exception frames
+ * Adds local variables to exception frames.
+ * @deprecated Use `localVariablesAsyncIntegration()` instead.
  */
 export declare const LocalVariablesAsync: IntegrationClass<Integration & {
     processEvent: (event: Event) => Event;
     setup: (client: NodeClient) => void;
 }>;
+export type LocalVariablesAsync = typeof LocalVariablesAsync;
 //# sourceMappingURL=local-variables-async.d.ts.map

package/types-ts3.8/integrations/local-variables/local-variables-sync.d.ts

@@ -19,12 +19,15 @@ type CallbackWrapper<T> = {
 };
 /** Creates a container for callbacks to be called sequentially */
 export declare function createCallbackList<T>(complete: Next<T>): CallbackWrapper<T>;
+export declare const localVariablesSyncIntegration: (options?: LocalVariablesIntegrationOptions | undefined, session?: DebugSession | undefined) => import("@sentry/types").IntegrationFnResult;
 /**
- * Adds local variables to exception frames
+ * Adds local variables to exception frames.
+ * @deprecated Use `localVariablesSyncIntegration()` instead.
  */
 export declare const LocalVariablesSync: IntegrationClass<Integration & {
     processEvent: (event: Event) => Event;
     setup: (client: NodeClient) => void;
 }> & (new (options?: LocalVariablesIntegrationOptions, session?: DebugSession) => Integration);
+export type LocalVariablesSync = typeof LocalVariablesSync;
 export {};
 //# sourceMappingURL=local-variables-sync.d.ts.map

package/types-ts3.8/integrations/modules.d.ts

@@ -1,6 +1,11 @@
 import { Event, Integration, IntegrationClass } from '@sentry/types';
-/** Add node modules / packages to the event */
+export declare const modulesIntegration: () => import("@sentry/types").IntegrationFnResult;
+/**
+ * Add node modules / packages to the event.
+ * @deprecated Use `modulesIntegration()` instead.
+ */
 export declare const Modules: IntegrationClass<Integration & {
     processEvent: (event: Event) => Event;
 }>;
+export type Modules = typeof Modules;
 //# sourceMappingURL=modules.d.ts.map

package/types-ts3.8/integrations/onuncaughtexception.d.ts

@@ -19,13 +19,18 @@ interface OnUncaughtExceptionOptions {
      */
     onFatalError?(this: void, firstError: Error, secondError?: Error): void;
 }
-/** Global Exception handler */
+export declare const onUncaughtExceptionIntegration: (options?: Partial<OnUncaughtExceptionOptions> | undefined) => import("@sentry/types").IntegrationFnResult;
+/**
+ * Global Exception handler.
+ * @deprecated Use `onUncaughtExceptionIntegration()` instead.
+ */
 export declare const OnUncaughtException: IntegrationClass<Integration & {
     setup: (client: NodeClient) => void;
 }> & (new (options?: Partial<{
     exitEvenIfOtherHandlersAreRegistered: boolean;
     onFatalError?(this: void, firstError: Error, secondError?: Error): void;
 }> | undefined) => Integration);
+export type OnUncaughtException = typeof OnUncaughtException;
 type ErrorHandler = {
     _errorHandler: boolean;
 } & ((error: Error) => void);

package/types-ts3.8/integrations/onunhandledrejection.d.ts

@@ -7,12 +7,17 @@ interface OnUnhandledRejectionOptions {
      */
     mode: UnhandledRejectionMode;
 }
-/** Global Promise Rejection handler */
+export declare const onUnhandledRejectionIntegration: (options?: Partial<OnUnhandledRejectionOptions> | undefined) => import("@sentry/types").IntegrationFnResult;
+/**
+ * Global Promise Rejection handler.
+ * @deprecated Use `onUnhandledRejectionIntegration()` instead.
+ */
 export declare const OnUnhandledRejection: IntegrationClass<Integration & {
     setup: (client: Client) => void;
 }> & (new (options?: Partial<{
     mode: UnhandledRejectionMode;
 }>) => Integration);
+export type OnUnhandledRejection = typeof OnUnhandledRejection;
 /**
  * Send an exception with reason
  * @param reason string

package/types-ts3.8/integrations/spotlight.d.ts

@@ -1,17 +1,28 @@
 import * as http from 'http';
 import { Client, Integration, IntegrationClass } from '@sentry/types';
+type SpotlightConnectionOptions = {
+    /**
+     * Set this if the Spotlight Sidecar is not running on localhost:8969
+     * By default, the Url is set to http://localhost:8969/stream
+     */
+    sidecarUrl?: string;
+};
+export declare const spotlightIntegration: (options?: Partial<SpotlightConnectionOptions> | undefined) => import("@sentry/types").IntegrationFnResult;
 /**
  * Use this integration to send errors and transactions to Spotlight.
  *
  * Learn more about spotlight at https://spotlightjs.com
  *
- * Important: This integration only works with Node 18 or newer
+ * Important: This integration only works with Node 18 or newer.
+ *
+ * @deprecated Use `spotlightIntegration()` instead.
  */
 export declare const Spotlight: IntegrationClass<Integration & {
     setup: (client: Client) => void;
 }> & (new (options?: Partial<{
     sidecarUrl?: string;
 }>) => Integration);
+export type Spotlight = typeof Spotlight;
 type HttpRequestImpl = typeof http.request;
 /**
  * We want to get an unpatched http request implementation to avoid capturing our own calls.

package/types-ts3.8/integrations/undici/index.d.ts

@@ -1,4 +1,4 @@
-import { EventProcessor, Integration } from '@sentry/types';
+import { EventProcessor, Integration, IntegrationFnResult } from '@sentry/types';
 export declare enum ChannelName {
     RequestCreate = "undici:request:create",
     RequestEnd = "undici:request:headers",
@@ -10,12 +10,18 @@ export interface UndiciOptions {
      * Defaults to true
      */
     breadcrumbs: boolean;
+    /**
+     * Whether tracing spans should be created for requests
+     * If not set, this will be enabled/disabled based on if tracing is enabled.
+     */
+    tracing?: boolean;
     /**
      * Function determining whether or not to create spans to track outgoing requests to the given URL.
      * By default, spans will be created for all outgoing requests.
      */
     shouldCreateSpanForRequest?: (url: string) => boolean;
 }
+export declare const nativeNodeFetchintegration: (options?: Partial<UndiciOptions> | undefined) => IntegrationFnResult;
 /**
  * Instruments outgoing HTTP requests made with the `undici` package via
  * Node's `diagnostics_channel` API.
@@ -23,6 +29,8 @@ export interface UndiciOptions {
  * Supports Undici 4.7.0 or higher.
  *
  * Requires Node 16.17.0 or higher.
+ *
+ * @deprecated Use `nativeNodeFetchintegration()` instead.
  */
 export declare class Undici implements Integration {
     /**

package/types-ts3.8/sdk.d.ts

@@ -1,19 +1,8 @@
 import { Integration, Options, StackParser } from '@sentry/types';
 import { NodeClient } from './client';
-import { Http, Undici } from './integrations';
 import { NodeOptions } from './types';
 /** @deprecated Use `getDefaultIntegrations(options)` instead. */
-export declare const defaultIntegrations: ((Integration & {
-    setup: (client: import("@sentry/types").Client<import("@sentry/types").ClientOptions<import("@sentry/types").BaseTransportOptions>>) => void;
-}) | Http | (Integration & {
-    processEvent: (event: import("@sentry/types").Event) => Promise<import("@sentry/types").Event>;
-}) | Undici | (Integration & {
-    preprocessEvent: (event: import("@sentry/types").Event, hint: import("@sentry/types").EventHint, client: import("@sentry/types").Client<import("@sentry/types").ClientOptions<import("@sentry/types").BaseTransportOptions>>) => void;
-}) | (Integration & {
-    setupOnce: () => void;
-}) | (Integration & {
-    processEvent: (event: import("@sentry/types").Event, hint: import("@sentry/types").EventHint, client: import("@sentry/types").Client<import("@sentry/types").ClientOptions<import("@sentry/types").BaseTransportOptions>>) => import("@sentry/types").Event;
-}))[];
+export declare const defaultIntegrations: import("@sentry/types").IntegrationFnResult[];
 /** Get the default integrations for the Node SDK. */
 export declare function getDefaultIntegrations(_options: Options): Integration[];
 /**