@sentry/node 9.9.0 → 9.10.0

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

@@ -1,4 +1,5 @@
-export declare const instrumentGenericPool: ((options?: unknown) => void) & {
+import { GenericPoolInstrumentation } from '@opentelemetry/instrumentation-generic-pool';
+export declare const instrumentGenericPool: ((options?: unknown) => GenericPoolInstrumentation) & {
     id: string;
 };
 /**

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

@@ -24,7 +24,7 @@ interface GraphqlOptions {
      */
     useOperationNameForRootSpan?: boolean;
 }
-export declare const instrumentGraphql: ((options?: GraphqlOptions | undefined) => void) & {
+export declare const instrumentGraphql: ((options?: GraphqlOptions | undefined) => import("@opentelemetry/instrumentation").Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
     id: string;
 };
 /**

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

@@ -1,5 +1,6 @@
+import { HapiInstrumentation } from '@opentelemetry/instrumentation-hapi';
 import { Server } from './types';
-export declare const instrumentHapi: ((options?: unknown) => void) & {
+export declare const instrumentHapi: ((options?: unknown) => HapiInstrumentation) & {
     id: string;
 };
 /**

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

@@ -1,4 +1,5 @@
-export declare const instrumentKafka: ((options?: unknown) => void) & {
+import { KafkaJsInstrumentation } from '@opentelemetry/instrumentation-kafkajs';
+export declare const instrumentKafka: ((options?: unknown) => KafkaJsInstrumentation) & {
     id: string;
 };
 /**

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

@@ -1,4 +1,5 @@
-export declare const instrumentKnex: ((options?: unknown) => void) & {
+import { KnexInstrumentation } from '@opentelemetry/instrumentation-knex';
+export declare const instrumentKnex: ((options?: unknown) => KnexInstrumentation) & {
     id: string;
 };
 /**

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

@@ -1,4 +1,5 @@
-export declare const instrumentKoa: ((options?: unknown) => void) & {
+import { KoaInstrumentation } from '@opentelemetry/instrumentation-koa';
+export declare const instrumentKoa: ((options?: unknown) => KoaInstrumentation) & {
     id: string;
 };
 /**

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

@@ -1,4 +1,5 @@
-export declare const instrumentLruMemoizer: ((options?: unknown) => void) & {
+import { LruMemoizerInstrumentation } from '@opentelemetry/instrumentation-lru-memoizer';
+export declare const instrumentLruMemoizer: ((options?: unknown) => LruMemoizerInstrumentation) & {
     id: string;
 };
 /**

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

@@ -1,4 +1,5 @@
-export declare const instrumentMongo: ((options?: unknown) => void) & {
+import { MongoDBInstrumentation } from '@opentelemetry/instrumentation-mongodb';
+export declare const instrumentMongo: ((options?: unknown) => MongoDBInstrumentation) & {
     id: string;
 };
 /**

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

@@ -1,4 +1,5 @@
-export declare const instrumentMongoose: ((options?: unknown) => void) & {
+import { MongooseInstrumentation } from '@opentelemetry/instrumentation-mongoose';
+export declare const instrumentMongoose: ((options?: unknown) => MongooseInstrumentation) & {
     id: string;
 };
 /**

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

@@ -1,4 +1,5 @@
-export declare const instrumentMysql: ((options?: unknown) => void) & {
+import { MySQLInstrumentation } from '@opentelemetry/instrumentation-mysql';
+export declare const instrumentMysql: ((options?: unknown) => MySQLInstrumentation) & {
     id: string;
 };
 /**

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

@@ -1,4 +1,5 @@
-export declare const instrumentMysql2: ((options?: unknown) => void) & {
+import { MySQL2Instrumentation } from '@opentelemetry/instrumentation-mysql2';
+export declare const instrumentMysql2: ((options?: unknown) => MySQL2Instrumentation) & {
     id: string;
 };
 /**

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

@@ -1,4 +1,5 @@
-export declare const instrumentPostgres: ((options?: unknown) => void) & {
+import { PgInstrumentation } from '@opentelemetry/instrumentation-pg';
+export declare const instrumentPostgres: ((options?: unknown) => PgInstrumentation) & {
     id: string;
 };
 /**

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

@@ -1,7 +1,7 @@
 import { Instrumentation } from '@opentelemetry/instrumentation';
 export declare const instrumentPrisma: ((options?: {
     prismaInstrumentation?: Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig> | undefined;
-} | undefined) => void) & {
+} | undefined) => Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
     id: string;
 };
 /**

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

@@ -1,4 +1,5 @@
-export declare const instrumentTedious: ((options?: unknown) => void) & {
+import { TediousInstrumentation } from '@opentelemetry/instrumentation-tedious';
+export declare const instrumentTedious: ((options?: unknown) => TediousInstrumentation) & {
     id: string;
 };
 /**

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

@@ -1,4 +1,5 @@
-export declare const instrumentVercelAi: ((options?: unknown) => void) & {
+import { SentryVercelAiInstrumentation } from './instrumentation';
+export declare const instrumentVercelAi: ((options?: unknown) => SentryVercelAiInstrumentation) & {
     id: string;
 };
 /**

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

@@ -1,6 +1,5 @@
 import { InstrumentationBase } from '@opentelemetry/instrumentation';
 import { InstrumentationConfig, InstrumentationModuleDefinition } from '@opentelemetry/instrumentation';
-export declare let sentryVercelAiPatched: boolean;
 /**
  * This detects is added by the Sentry Vercel AI Integration to detect if the integration should
  * be enabled.
@@ -8,11 +7,18 @@ export declare let sentryVercelAiPatched: boolean;
  * It also patches the `ai` module to enable Vercel AI telemetry automatically for all methods.
  */
 export declare class SentryVercelAiInstrumentation extends InstrumentationBase {
+    private _isPatched;
+    private _callbacks;
     constructor(config?: InstrumentationConfig);
     /**
      * Initializes the instrumentation by defining the modules to be patched.
      */
     init(): InstrumentationModuleDefinition;
+    /**
+     * Call the provided callback when the module is patched.
+     * If it has already been patched, the callback will be called immediately.
+     */
+    callWhenPatched(callback: () => void): void;
     /**
      * Patches module exports to enable Vercel AI telemetry.
      */

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

@@ -0,0 +1,158 @@
+import { Log, ParameterizedString } from '@sentry/core';
+type CaptureLogArgs = [
+    /*message*/ ParameterizedString,
+    /*attributes*/ Log['attributes']
+] | [
+    /*messageTemplate*/ string,
+    /*messageParams*/ Array<unknown>,
+    /*attributes*/ Log['attributes']
+];
+/**
+ * @summary Capture a log with the `trace` level. Requires `_experiments.enableLogs` to be enabled.
+ *
+ * You can either pass a message and attributes or a message template, params and attributes.
+ *
+ * @example
+ *
+ * ```
+ * Sentry.logger.trace('Starting database connection', {
+ *   database: 'users',
+ *   connectionId: 'conn_123'
+ * });
+ * ```
+ *
+ * @example With template strings
+ *
+ * ```
+ * Sentry.logger.trace('Database connection %s established for %s',
+ *   ['successful', 'users'],
+ *   { connectionId: 'conn_123' }
+ * );
+ * ```
+ */
+export declare function trace(...args: CaptureLogArgs): void;
+/**
+ * @summary Capture a log with the `debug` level. Requires `_experiments.enableLogs` to be enabled.
+ *
+ * You can either pass a message and attributes or a message template, params and attributes.
+ *
+ * @example
+ *
+ * ```
+ * Sentry.logger.debug('Cache miss for user profile', {
+ *   userId: 'user_123',
+ *   cacheKey: 'profile:user_123'
+ * });
+ * ```
+ *
+ * @example With template strings
+ *
+ * ```
+ * Sentry.logger.debug('Cache %s for %s: %s',
+ *   ['miss', 'user profile', 'key not found'],
+ *   { userId: 'user_123' }
+ * );
+ * ```
+ */
+export declare function debug(...args: CaptureLogArgs): void;
+/**
+ * @summary Capture a log with the `info` level. Requires `_experiments.enableLogs` to be enabled.
+ *
+ * You can either pass a message and attributes or a message template, params and attributes.
+ *
+ * @example
+ *
+ * ```
+ * Sentry.logger.info('User profile updated', {
+ *   userId: 'user_123',
+ *   updatedFields: ['email', 'preferences']
+ * });
+ * ```
+ *
+ * @example With template strings
+ *
+ * ```
+ * Sentry.logger.info('User %s updated their %s',
+ *   ['John Doe', 'profile settings'],
+ *   { userId: 'user_123' }
+ * );
+ * ```
+ */
+export declare function info(...args: CaptureLogArgs): void;
+/**
+ * @summary Capture a log with the `warn` level. Requires `_experiments.enableLogs` to be enabled.
+ *
+ * You can either pass a message and attributes or a message template, params and attributes.
+ *
+ * @example
+ *
+ * ```
+ * Sentry.logger.warn('Rate limit approaching', {
+ *   endpoint: '/api/users',
+ *   currentRate: '95/100',
+ *   resetTime: '2024-03-20T10:00:00Z'
+ * });
+ * ```
+ *
+ * @example With template strings
+ *
+ * ```
+ * Sentry.logger.warn('Rate limit %s for %s: %s',
+ *   ['approaching', '/api/users', '95/100 requests'],
+ *   { resetTime: '2024-03-20T10:00:00Z' }
+ * );
+ * ```
+ */
+export declare function warn(...args: CaptureLogArgs): void;
+/**
+ * @summary Capture a log with the `error` level. Requires `_experiments.enableLogs` to be enabled.
+ *
+ * You can either pass a message and attributes or a message template, params and attributes.
+ *
+ * @example
+ *
+ * ```
+ * Sentry.logger.error('Failed to process payment', {
+ *   orderId: 'order_123',
+ *   errorCode: 'PAYMENT_FAILED',
+ *   amount: 99.99
+ * });
+ * ```
+ *
+ * @example With template strings
+ *
+ * ```
+ * Sentry.logger.error('Payment processing failed for order %s: %s',
+ *   ['order_123', 'insufficient funds'],
+ *   { amount: 99.99 }
+ * );
+ * ```
+ */
+export declare function error(...args: CaptureLogArgs): void;
+/**
+ * @summary Capture a log with the `fatal` level. Requires `_experiments.enableLogs` to be enabled.
+ *
+ * You can either pass a message and attributes or a message template, params and attributes.
+ *
+ * @example
+ *
+ * ```
+ * Sentry.logger.fatal('Database connection pool exhausted', {
+ *   database: 'users',
+ *   activeConnections: 100,
+ *   maxConnections: 100
+ * });
+ * ```
+ *
+ * @example With template strings
+ *
+ * ```
+ * Sentry.logger.fatal('Database %s: %s connections active',
+ *   ['connection pool exhausted', '100/100'],
+ *   { database: 'users' }
+ * );
+ * ```
+ */
+export declare function fatal(...args: CaptureLogArgs): void;
+export { fmt } from '@sentry/core';
+//# sourceMappingURL=log.d.ts.map

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

@@ -5,7 +5,20 @@ export declare const INSTRUMENTED: Record<string, Instrumentation>;
  * Instrument an OpenTelemetry instrumentation once.
  * This will skip running instrumentation again if it was already instrumented.
  */
-export declare function generateInstrumentOnce<Options = unknown>(name: string, creator: (options?: Options) => Instrumentation): ((options?: Options) => void) & {
+export declare function generateInstrumentOnce<Options = unknown, InstrumentationInstance extends Instrumentation = Instrumentation>(name: string, creator: (options?: Options) => InstrumentationInstance): ((options?: Options) => InstrumentationInstance) & {
     id: string;
 };
+/**
+ * Ensure a given callback is called when the instrumentation is actually wrapping something.
+ * This can be used to ensure some logic is only called when the instrumentation is actually active.
+ *
+ * This function returns a function that can be invoked with a callback.
+ * This callback will either be invoked immediately
+ * (e.g. if the instrumentation was already wrapped, or if _wrap could not be patched),
+ * or once the instrumentation is actually wrapping something.
+ *
+ * Make sure to call this function right after adding the instrumentation, otherwise it may be too late!
+ * The returned callback can be used any time, and also multiple times.
+ */
+export declare function instrumentWhenWrapped<T extends Instrumentation>(instrumentation: T): (callback: () => void) => void;
 //# sourceMappingURL=instrument.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/node",
-  "version": "9.9.0",
+  "version": "9.10.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",
@@ -96,8 +96,8 @@
     "@opentelemetry/sdk-trace-base": "^1.30.1",
     "@opentelemetry/semantic-conventions": "^1.30.0",
     "@prisma/instrumentation": "6.5.0",
-    "@sentry/core": "9.9.0",
-    "@sentry/opentelemetry": "9.9.0",
+    "@sentry/core": "9.10.0",
+    "@sentry/opentelemetry": "9.10.0",
     "import-in-the-middle": "^1.13.0"
   },
   "devDependencies": {