@sentry/node 8.41.0-beta.1 → 8.42.0

package/build/types-ts3.8/integrations/tracing/graphql.d.ts

@@ -42,6 +42,6 @@ export declare const instrumentGraphql: ((options?: GraphqlOptions | undefined)
  *  integrations: [Sentry.graphqlIntegration()],
  * });
  */
-export declare const graphqlIntegration: (options?: GraphqlOptions | undefined) => import("@sentry/types").Integration;
+export declare const graphqlIntegration: (options?: GraphqlOptions | undefined) => import("@sentry/core").Integration;
 export {};
 //# sourceMappingURL=graphql.d.ts.map

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

@@ -18,7 +18,7 @@ export declare const instrumentHapi: ((options?: unknown) => void) & {
  * })
  * ```
  */
-export declare const hapiIntegration: () => import("@sentry/types").Integration;
+export declare const hapiIntegration: () => import("@sentry/core").Integration;
 export declare const hapiErrorPlugin: {
     name: string;
     version: string;

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

@@ -1,4 +1,4 @@
-import { Integration } from '@sentry/types';
+import { Integration } from '@sentry/core';
 /**
  * With OTEL, all performance integrations will be added, as OTEL only initializes them when the patched package is actually required.
  */

package/build/types-ts3.8/integrations/tracing/kafka.d.ts

@@ -14,5 +14,5 @@ export declare const instrumentKafka: ((options?: unknown) => void) & {
  *  integrations: [Sentry.kafkaIntegration()],
  * });
  */
-export declare const kafkaIntegration: () => import("@sentry/types").Integration;
+export declare const kafkaIntegration: () => import("@sentry/core").Integration;
 //# sourceMappingURL=kafka.d.ts.map

package/build/types-ts3.8/integrations/tracing/knex.d.ts

@@ -15,5 +15,5 @@ export declare const instrumentKnex: ((options?: unknown) => void) & {
  * });
  * ```
  */
-export declare const knexIntegration: () => import("@sentry/types").Integration;
+export declare const knexIntegration: () => import("@sentry/core").Integration;
 //# sourceMappingURL=knex.d.ts.map

package/build/types-ts3.8/integrations/tracing/koa.d.ts

@@ -17,7 +17,7 @@ export declare const instrumentKoa: ((options?: unknown) => void) & {
  * })
  * ```
  */
-export declare const koaIntegration: () => import("@sentry/types").Integration;
+export declare const koaIntegration: () => import("@sentry/core").Integration;
 /**
  * Add an Koa error handler to capture errors to Sentry.
  *

package/build/types-ts3.8/integrations/tracing/lrumemoizer.d.ts

@@ -14,5 +14,5 @@ export declare const instrumentLruMemoizer: ((options?: unknown) => void) & {
  *  integrations: [Sentry.lruMemoizerIntegration()],
  * });
  */
-export declare const lruMemoizerIntegration: () => import("@sentry/types").Integration;
+export declare const lruMemoizerIntegration: () => import("@sentry/core").Integration;
 //# sourceMappingURL=lrumemoizer.d.ts.map

package/build/types-ts3.8/integrations/tracing/mongo.d.ts

@@ -19,5 +19,5 @@ export declare function _defaultDbStatementSerializer(commandObj: Record<string,
  * });
  * ```
  */
-export declare const mongoIntegration: () => import("@sentry/types").Integration;
+export declare const mongoIntegration: () => import("@sentry/core").Integration;
 //# sourceMappingURL=mongo.d.ts.map

package/build/types-ts3.8/integrations/tracing/mongoose.d.ts

@@ -15,5 +15,5 @@ export declare const instrumentMongoose: ((options?: unknown) => void) & {
  * });
  * ```
  */
-export declare const mongooseIntegration: () => import("@sentry/types").Integration;
+export declare const mongooseIntegration: () => import("@sentry/core").Integration;
 //# sourceMappingURL=mongoose.d.ts.map

package/build/types-ts3.8/integrations/tracing/mysql.d.ts

@@ -1,18 +1,4 @@
 export declare const instrumentMysql: ((options?: unknown) => void) & {
-    /**
-     * Adds Sentry tracing instrumentation for the [mysql](https://www.npmjs.com/package/mysql) library.
-     *
-     * For more information, see the [`mysqlIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mysql/).
-     *
-     * @example
-     * ```javascript
-     * const Sentry = require('@sentry/node');
-     *
-     * Sentry.init({
-     *  integrations: [Sentry.mysqlIntegration()],
-     * });
-     * ```
-     */
     id: string;
 };
 /**
@@ -29,5 +15,5 @@ export declare const instrumentMysql: ((options?: unknown) => void) & {
  * });
  * ```
  */
-export declare const mysqlIntegration: () => import("@sentry/types").Integration;
+export declare const mysqlIntegration: () => import("@sentry/core").Integration;
 //# sourceMappingURL=mysql.d.ts.map

package/build/types-ts3.8/integrations/tracing/mysql2.d.ts

@@ -15,5 +15,5 @@ export declare const instrumentMysql2: ((options?: unknown) => void) & {
  * });
  * ```
  */
-export declare const mysql2Integration: () => import("@sentry/types").Integration;
+export declare const mysql2Integration: () => import("@sentry/core").Integration;
 //# sourceMappingURL=mysql2.d.ts.map

package/build/types-ts3.8/integrations/tracing/nest/helpers.d.ts

@@ -1,4 +1,4 @@
-import { Span } from '@sentry/types';
+import { Span } from '@sentry/core';
 import { CatchTarget, InjectableTarget, NextFunction, Observable } from './types';
 /**
  * Helper checking if a concrete target class is already patched.

package/build/types-ts3.8/integrations/tracing/nest/nest.d.ts

@@ -7,7 +7,7 @@ export declare const instrumentNest: (() => void) & {
  *
  * @deprecated The `nestIntegration` is deprecated. Instead, use the NestJS SDK directly (`@sentry/nestjs`), or use the `nestIntegration` export from `@sentry/nestjs`.
  */
-export declare const nestIntegration: () => import("@sentry/types").Integration;
+export declare const nestIntegration: () => import("@sentry/core").Integration;
 /**
  * Setup an error handler for Nest.
  *

package/build/types-ts3.8/integrations/tracing/postgres.d.ts

@@ -15,5 +15,5 @@ export declare const instrumentPostgres: ((options?: unknown) => void) & {
  * });
  * ```
  */
-export declare const postgresIntegration: () => import("@sentry/types").Integration;
+export declare const postgresIntegration: () => import("@sentry/core").Integration;
 //# sourceMappingURL=postgres.d.ts.map

package/build/types-ts3.8/integrations/tracing/prisma.d.ts

@@ -28,5 +28,5 @@ export declare const instrumentPrisma: ((options?: unknown) => void) & {
  * });
  * ```
  */
-export declare const prismaIntegration: () => import("@sentry/types").Integration;
+export declare const prismaIntegration: () => import("@sentry/core").Integration;
 //# sourceMappingURL=prisma.d.ts.map

package/build/types-ts3.8/integrations/tracing/redis.d.ts

@@ -20,6 +20,6 @@ export declare const instrumentRedis: (() => void) & {
  * });
  * ```
  */
-export declare const redisIntegration: (options?: RedisOptions | undefined) => import("@sentry/types").Integration;
+export declare const redisIntegration: (options?: RedisOptions | undefined) => import("@sentry/core").Integration;
 export {};
 //# sourceMappingURL=redis.d.ts.map

package/build/types-ts3.8/integrations/tracing/tedious.d.ts

@@ -15,5 +15,5 @@ export declare const instrumentTedious: ((options?: unknown) => void) & {
  * });
  * ```
  */
-export declare const tediousIntegration: () => import("@sentry/types").Integration;
+export declare const tediousIntegration: () => import("@sentry/core").Integration;
 //# sourceMappingURL=tedious.d.ts.map

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

@@ -1,4 +1,4 @@
-import { StackParser } from '@sentry/types';
+import { StackParser } from '@sentry/core';
 /**
  * Returns a release dynamically from environment variables.
  */

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

@@ -1,5 +1,6 @@
 import { Tracer } from '@opentelemetry/api';
 import { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
+import { DynamicSamplingContext, Scope, TraceContext } from '@sentry/core';
 import { ServerRuntimeClient } from '@sentry/core';
 import { NodeClientOptions } from '../types';
 /** A client for using Sentry with Node & OpenTelemetry. */
@@ -21,5 +22,10 @@ export declare class NodeClient extends ServerRuntimeClient<NodeClientOptions> {
      * result in a memory leak.
      */
     startClientReportTracking(): void;
+    /** Custom implementation for OTEL, so we can handle scope-span linking. */
+    protected _getTraceInfoFromScope(scope: Scope | undefined): [
+        /*dynamicSamplingContext*/ Partial<DynamicSamplingContext> | undefined,
+        /*traceContext*/ TraceContext | undefined
+    ];
 }
 //# sourceMappingURL=client.d.ts.map

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

@@ -1,4 +1,4 @@
-import { Integration, Options } from '@sentry/types';
+import { Integration, Options } from '@sentry/core';
 import { NodeOptions } from '../types';
 import { NodeClient } from './client';
 /**

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

@@ -1,4 +1,4 @@
-import { Scope } from '@sentry/types';
+import { Scope } from '@sentry/core';
 /**
  * Update the active isolation scope.
  * Should be used with caution!

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { BaseTransportOptions, Transport } from '@sentry/types';
+import { BaseTransportOptions, Transport } from '@sentry/core';
 import { HTTPModule } from './http-module';
 export interface NodeTransportOptions extends BaseTransportOptions {
     /** Define custom headers */

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

@@ -1,10 +1,26 @@
 import { Span as WriteableSpan } from '@opentelemetry/api';
+import { Instrumentation } from '@opentelemetry/instrumentation';
 import { ReadableSpan } from '@opentelemetry/sdk-trace-base';
-import { ClientOptions, Options, SamplingContext, Scope, Span, TracePropagationTargets } from '@sentry/types';
+import { ClientOptions, Options, SamplingContext, Scope, Span, TracePropagationTargets } from '@sentry/core';
 import { NodeTransportOptions } from './transports';
+/**
+ * Note: In the next major version of the Sentry SDK this interface will be removed and the SDK will by default only wrap
+ * ESM modules that are required to be wrapped by OpenTelemetry Instrumentation.
+ */
 export interface EsmLoaderHookOptions {
+    /**
+     * Provide a list of modules to wrap with `import-in-the-middle`.
+     *
+     * @deprecated It is recommended to use `onlyIncludeInstrumentedModules: true` instead of manually defining modules to include and exclude.
+     */
     include?: Array<string | RegExp>;
-    exclude?: Array<string | RegExp> /**
+    /**
+     * Provide a list of modules to prevent them from being wrapped with `import-in-the-middle`.
+     *
+     * @deprecated It is recommended to use `onlyIncludeInstrumentedModules: true` instead of manually defining modules to include and exclude.
+     */
+    exclude?: Array<string | RegExp>;
+    /**
      * When set to `true`, `import-in-the-middle` will only wrap ESM modules that are specifically instrumented by
      * OpenTelemetry plugins. This is useful to avoid issues where `import-in-the-middle` is not compatible with some of
      * your dependencies.
@@ -14,7 +30,10 @@ export interface EsmLoaderHookOptions {
      * `Sentry.init()`.
      *
      * Defaults to `false`.
-     */;
+     *
+     * Note: In the next major version of the Sentry SDK this option will be removed and the SDK will by default only wrap
+     * ESM modules that are required to be wrapped by OpenTelemetry Instrumentation.
+     */
     onlyIncludeInstrumentedModules?: boolean;
 }
 export interface BaseNodeOptions {
@@ -78,8 +97,16 @@ export interface BaseNodeOptions {
      * * The `SentryPropagator`
      * * The `SentryContextManager`
      * * The `SentrySampler`
+     *
+     * If you are registering your own OpenTelemetry Loader Hooks (or `import-in-the-middle` hooks), it is also recommended to set the `registerEsmLoaderHooks` option to false.
      */
     skipOpenTelemetrySetup?: boolean;
+    /**
+     * Provide an array of OpenTelemetry Instrumentations that should be registered.
+     *
+     * Use this option if you want to register OpenTelemetry instrumentation that the Sentry SDK does not yet have support for.
+     */
+    openTelemetryInstrumentations?: Instrumentation[];
     /**
      * The max. duration in seconds that the SDK will wait for parent spans to be finished before discarding a span.
      * The SDK will automatically clean up spans that have no finished parent after this duration.
@@ -106,6 +133,9 @@ export interface BaseNodeOptions {
      * ```
      *
      * Defaults to `true`.
+     *
+     * Note: In the next major version of the SDK, the possibility to provide fine-grained control will be removed from this option.
+     * This means that it will only be possible to pass `true` or `false`. The default value will continue to be `true`.
      */
     registerEsmLoaderHooks?: boolean | EsmLoaderHookOptions;
     /**
@@ -122,7 +152,7 @@ export interface BaseNodeOptions {
 }
 /**
  * Configuration options for the Sentry Node SDK
- * @see @sentry/types Options for more information.
+ * @see @sentry/core Options for more information.
  */
 export interface NodeOptions extends Options<NodeTransportOptions>, BaseNodeOptions {
 }
@@ -140,7 +170,7 @@ export interface CurrentScopes {
  * The base `Span` type is basically a `WriteableSpan`.
  * There are places where we basically want to allow passing _any_ span,
  * so in these cases we type this as `AbstractSpan` which could be either a regular `Span` or a `ReadableSpan`.
- * You'll have to make sur to check revelant fields before accessing them.
+ * You'll have to make sur to check relevant fields before accessing them.
  *
  * Note that technically, the `Span` exported from `@opentelemetry/sdk-trace-base` matches this,
  * but we cannot be 100% sure that we are actually getting such a span, so this type is more defensive.

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

@@ -1,5 +1,5 @@
 import { Span } from '@opentelemetry/api';
-import { SpanOrigin } from '@sentry/types';
+import { SpanOrigin } from '@sentry/core';
 /** Adds an origin to an OTEL Span. */
 export declare function addOriginToSpan(span: Span, origin: SpanOrigin): void;
 //# sourceMappingURL=addOriginToSpan.d.ts.map

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

@@ -1,3 +1,3 @@
-import { MissingInstrumentationContext } from '@sentry/types';
+import { MissingInstrumentationContext } from '@sentry/core';
 export declare const createMissingInstrumentationContext: (pkg: string) => MissingInstrumentationContext;
 //# sourceMappingURL=createMissingInstrumentationContext.d.ts.map

package/build/types-ts3.8/utils/entry-point.d.ts

@@ -0,0 +1,24 @@
+export interface ProcessInterface {
+    execArgv: string[];
+    argv: string[];
+    cwd: () => string;
+}
+export interface ProcessArgs {
+    appPath: string;
+    importPaths: string[];
+    requirePaths: string[];
+}
+/**
+ * Parses the process arguments to determine the app path, import paths, and require paths.
+ */
+export declare function parseProcessPaths(proc: ProcessInterface): ProcessArgs;
+/**
+ * Gets the current entry point type.
+ *
+ * `app` means this function was most likely called via the app entry point.
+ * `import` means this function was most likely called from an --import cli arg.
+ * `require` means this function was most likely called from a --require cli arg.
+ * `unknown` means we couldn't determine for sure.
+ */
+export declare function getEntryPointType(proc?: ProcessInterface): 'import' | 'require' | 'app' | 'unknown';
+//# sourceMappingURL=entry-point.d.ts.map

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

@@ -1,4 +1,4 @@
-import { CaptureContext, EventHint, ScopeContext } from '@sentry/types';
+import { CaptureContext, EventHint, ScopeContext } from '@sentry/core';
 /**
  * This type makes sure that we get either a CaptureContext, OR an EventHint.
  * It does not allow mixing them, which could lead to unexpected outcomes, e.g. this is disallowed:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/node",
-  "version": "8.41.0-beta.1",
+  "version": "8.42.0",
   "description": "Sentry Node SDK using OpenTelemetry for performance instrumentation",
   "repository": "git://github.com/getsentry/sentry-javascript.git",
   "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/node",
@@ -97,9 +97,8 @@
     "@opentelemetry/sdk-trace-base": "^1.26.0",
     "@opentelemetry/semantic-conventions": "^1.27.0",
     "@prisma/instrumentation": "5.19.1",
-    "@sentry/core": "8.41.0-beta.1",
-    "@sentry/opentelemetry": "8.41.0-beta.1",
-    "@sentry/types": "8.41.0-beta.1",
+    "@sentry/core": "8.42.0",
+    "@sentry/opentelemetry": "8.42.0",
     "import-in-the-middle": "^1.11.2"
   },
   "devDependencies": {