heroku 11.0.2 → 11.1.0

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
 
+## [11.1.0](https://github.com/heroku/cli/compare/v11.0.2...v11.1.0) (2026-03-31)
+
+
+### Features
+
+* add isTTY context to telemetry and filter SIGINT from Sentry ([#3632](https://github.com/heroku/cli/issues/3632)) ([74bbdfb](https://github.com/heroku/cli/commit/74bbdfbe45eef40b7232c9159e3cc4a541290296))
+
+
+### Performance Improvements
+
+* optimize telemetry initialization and reduce startup overhead ([#3620](https://github.com/heroku/cli/issues/3620)) ([65575a0](https://github.com/heroku/cli/commit/65575a01f7da69d602af52d1991f880be23bd3df))
+
 ## [11.0.2](https://github.com/heroku/cli/compare/v11.0.1...v11.0.2) (2026-03-27)
 
 

package/README.md

@@ -1,23 +1,22 @@
-Heroku CLI
-==========
-
-![Heroku logo](https://d4yt8xl9b7in.cloudfront.net/assets/home/logotype-heroku.png)
-[![Node CI Suite](https://github.com/heroku/cli/actions/workflows/ci.yml/badge.svg)](https://github.com/heroku/cli/actions/workflows/ci.yml)
-[![npm](https://img.shields.io/npm/v/heroku.svg)](https://www.npmjs.com/package/heroku)
-[![ISC License](https://img.shields.io/github/license/heroku/cli.svg)](https://github.com/heroku/cli/blob/main/LICENSE)
-
-The Heroku CLI is used to manage Heroku apps from the command line. It is built using [oclif](https://oclif.io).
-
-For more about Heroku see <https://www.heroku.com/home>
+<div align="center">
+  <img src="assets/Heroku-Logo-Mark-Light-RGB.svg" alt="Heroku logo" width="100">
+  <p>&nbsp;</p>
 
-To get started see <https://devcenter.heroku.com/start>
+  [![Node CI Suite](https://github.com/heroku/cli/actions/workflows/ci.yml/badge.svg)](https://github.com/heroku/cli/actions/workflows/ci.yml)
+  [![npm](https://img.shields.io/npm/v/heroku.svg)](https://www.npmjs.com/package/heroku)
+  [![ISC License](https://img.shields.io/github/license/heroku/cli.svg)](https://github.com/heroku/cli/blob/main/LICENSE)
+</div>
 
 Overview
 ========
 
 The Heroku CLI is a command-line interface for managing Heroku applications and services. Built with Node.js and [oclif](https://oclif.io), it provides an extensible architecture for interacting with the Heroku platform.
 
-Key features include:
+For more about Heroku see <https://www.heroku.com/home>
+
+To get started see <https://devcenter.heroku.com/start>
+
+Key features of the CLI include:
 
 - **App management** - Deploy, scale, and monitor your applications
 - **Heroku Postgres database management** - Backup, restore, and manage Heroku Postgres databases
@@ -116,8 +115,7 @@ Using WebStorm (from JetBrains / IntelliJ), you can run/debug an individual test
 - Create a new run/debug configuration
 - Select the 'Mocha' type
 
-Releasing
+Contributing
 =========
-See the [Heroku CLI Release Steps](https://salesforce.quip.com/aPLDA1ZwjNlW).
 
-Review our [PR guidelines](./.github/PULL_REQUEST_TEMPLATE.md).
+Please review our [Contributing guidelines](./CONTRIBUTING.md) as well as our [PR template](./.github/PULL_REQUEST_TEMPLATE.md).

package/bin/run.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env -S node --no-deprecation
-/* eslint-disable n/no-process-exit */
+
 /* eslint-disable n/no-unpublished-bin */
 
 import {execute, settings} from '@oclif/core'
 
-// Enable performance tracking when DEBUG=oclif:perf or DEBUG=* is set
-if (process.env.DEBUG?.includes('oclif:perf') || process.env.DEBUG === '*') {
+// Enable performance tracking when oclif:perf is specified in DEBUG
+if (process.env.DEBUG?.includes('oclif:perf') || process.env.DEBUG === 'oclif:*' || process.env.DEBUG === '*') {
   settings.performanceEnabled = true
 }
 
@@ -16,54 +16,18 @@ const cliStartTime = now.getTime()
 
 // Skip telemetry entirely on Windows for performance (unless explicitly enabled)
 const enableTelemetry = process.platform !== 'win32' || process.env.ENABLE_WINDOWS_TELEMETRY === 'true'
-let globalTelemetry
-
-if (enableTelemetry) {
-  // Dynamically import telemetry only when needed
-  globalTelemetry = await import('../dist/global_telemetry.js')
-}
-
-process.once('beforeExit', async code => {
-  if (!enableTelemetry) return
-
-  // capture as successful exit
-  if (global.cliTelemetry) {
-    if (global.cliTelemetry.isVersionOrHelp) {
-      const cmdStartTime = global.cliTelemetry.commandRunDuration
-      global.cliTelemetry.commandRunDuration = globalTelemetry.computeDuration(cmdStartTime)
-    }
-
-    global.cliTelemetry.exitCode = code
-    global.cliTelemetry.cliRunDuration = globalTelemetry.computeDuration(cliStartTime)
-    const telemetryData = global.cliTelemetry
-    await globalTelemetry.sendTelemetry(telemetryData)
-  }
-})
-
-process.on('SIGINT', () => {
-  if (enableTelemetry) {
-    // Fire-and-forget: attempt to send telemetry but don't block exit
-    const error = new Error('Received SIGINT')
-    error.cliRunDuration = globalTelemetry.computeDuration(cliStartTime)
-    globalTelemetry.sendTelemetry(error).catch(() => {})
-  }
-
-  process.exit(1)
-})
-
-process.on('SIGTERM', () => {
-  if (enableTelemetry) {
-    // Fire-and-forget: attempt to send telemetry but don't block exit
-    const error = new Error('Received SIGTERM')
-    error.cliRunDuration = globalTelemetry.computeDuration(cliStartTime)
-    globalTelemetry.sendTelemetry(error).catch(() => {})
-  }
-
-  process.exit(1)
-})
 
 if (enableTelemetry) {
-  globalTelemetry.initializeInstrumentation()
+  // Dynamically import telemetry modules
+  const {setupTelemetryHandlers} = await import('../dist/lib/analytics-telemetry/worker-client.js')
+  const {computeDuration} = await import('../dist/lib/analytics-telemetry/telemetry-utils.js')
+
+  // Setup all telemetry handlers (beforeExit, SIGINT, SIGTERM)
+  setupTelemetryHandlers({
+    cliStartTime,
+    computeDuration,
+    enableTelemetry,
+  })
 }
 
 await execute({dir: import.meta.url})

package/dist/commands/domains/add.d.ts

@@ -1,6 +1,6 @@
 import { Command } from '@heroku-cli/command';
 import * as Heroku from '@heroku-cli/schema';
-declare type CertChoice = {
+type CertChoice = {
     name: string;
     value: null | string | undefined;
 };

package/dist/commands/pg/backups/schedule.d.ts

@@ -1,5 +1,5 @@
 import { Command } from '@heroku-cli/command';
-declare type BackupSchedule = {
+type BackupSchedule = {
     hour: string;
     timezone: string;
     schedule_name?: string;

package/dist/commands/spaces/index.d.ts

@@ -1,6 +1,6 @@
 import { Command } from '@heroku-cli/command';
 import { Space } from '../../lib/types/fir.js';
-declare type SpaceArray = Array<Required<Space>>;
+type SpaceArray = Array<Required<Space>>;
 export default class Index extends Command {
     static description: string;
     static flags: {

package/dist/commands/spaces/vpn/connections.d.ts

@@ -1,6 +1,6 @@
 import { Command } from '@heroku-cli/command';
 import * as Heroku from '@heroku-cli/schema';
-declare type VpnConnectionTunnels = Required<Heroku.PrivateSpacesVpn>['tunnels'];
+type VpnConnectionTunnels = Required<Heroku.PrivateSpacesVpn>['tunnels'];
 export default class Connections extends Command {
     static description: string;
     static example: string;

package/dist/hooks/command_not_found/performance_analytics.js

@@ -1,9 +1,10 @@
 const performance_analytics = async function () {
-    // Skip telemetry on Windows for performance (unless explicitly enabled)
-    if (process.platform === 'win32' && process.env.ENABLE_WINDOWS_TELEMETRY !== 'true') {
+    const { isTelemetryEnabled } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
+    const { reportCmdNotFound } = await import('../../lib/analytics-telemetry/global-telemetry.js');
+    // Use the consolidated telemetry check
+    if (!isTelemetryEnabled()) {
         return;
     }
-    const telemetry = await import('../../global_telemetry.js');
-    global.cliTelemetry = telemetry.reportCmdNotFound(this.config);
+    global.cliTelemetry = reportCmdNotFound(this.config);
 };
 export default performance_analytics;

package/dist/hooks/finally/sentry.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core/hooks';
+declare const finallyHook: Hook<'finally'>;
+export default finallyHook;

package/dist/hooks/finally/sentry.js

@@ -0,0 +1,42 @@
+/**
+ * Check if an error is a user error (not a bug) that should be filtered out
+ * Returns true if the error should NOT be sent to Sentry
+ */
+function isUserError(error) {
+    // Filter out 4xx HTTP errors (client errors)
+    if (error.statusCode && error.statusCode >= 400 && error.statusCode < 500) {
+        return true;
+    }
+    // Check for http.statusCode (e.g., HerokuAPIError)
+    if (error.http?.statusCode && error.http.statusCode >= 400 && error.http.statusCode < 500) {
+        return true;
+    }
+    // Filter out "command not found" errors (user typos, not bugs)
+    // Message format: "Run <bin> help for a list of available commands."
+    if (error.message && error.message.includes('Run') && error.message.includes('help') && error.message.includes('for a list of available commands')) {
+        return true;
+    }
+    // Also check for exit code 127 (command not found)
+    if (error.oclif?.exit === 127) {
+        return true;
+    }
+    return false;
+}
+const finallyHook = async function (options) {
+    // Only process if there was an error
+    if (!options.error) {
+        return;
+    }
+    // Filter out user errors (not bugs)
+    if (isUserError(options.error)) {
+        return;
+    }
+    const { isTelemetryEnabled, spawnTelemetryWorker } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
+    // Use the consolidated telemetry check
+    if (!isTelemetryEnabled()) {
+        return;
+    }
+    // Spawn background process to send error without blocking
+    spawnTelemetryWorker(options.error);
+};
+export default finallyHook;

package/dist/hooks/init/performance_analytics.js

@@ -1,9 +1,10 @@
 const performance_analytics = async function (options) {
-    // Skip telemetry on Windows for performance (unless explicitly enabled)
-    if (process.platform === 'win32' && process.env.ENABLE_WINDOWS_TELEMETRY !== 'true') {
+    const { isTelemetryEnabled } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
+    const { setupTelemetry } = await import('../../lib/analytics-telemetry/global-telemetry.js');
+    // Use the consolidated telemetry check
+    if (!isTelemetryEnabled()) {
         return;
     }
-    const telemetry = await import('../../global_telemetry.js');
-    global.cliTelemetry = telemetry.setupTelemetry(this.config, options);
+    global.cliTelemetry = setupTelemetry(this.config, options);
 };
 export default performance_analytics;

package/dist/hooks/postrun/performance_analytics.js

@@ -1,15 +1,15 @@
 const performance_analytics = async function () {
-    if (process.env.IS_HEROKU_TEST_ENV === 'true' || !global.cliTelemetry) {
+    const globalAny = global;
+    if (!globalAny.cliTelemetry) {
         return;
     }
-    // Skip analytics on Windows for performance (unless explicitly enabled)
-    if (process.platform === 'win32' && process.env.ENABLE_WINDOWS_TELEMETRY !== 'true') {
+    const { isTelemetryEnabled, computeDuration } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
+    // Use the consolidated telemetry check
+    if (!isTelemetryEnabled()) {
         return;
     }
-    const telemetry = await import('../../global_telemetry.js');
-    const globalAny = global;
     const cmdStartTime = globalAny.cliTelemetry.commandRunDuration;
-    globalAny.cliTelemetry.commandRunDuration = telemetry.computeDuration(cmdStartTime);
+    globalAny.cliTelemetry.commandRunDuration = computeDuration(cmdStartTime);
     globalAny.cliTelemetry.lifecycleHookCompletion.postrun = true;
     await Reflect.get(globalThis, 'recordPromise');
 };

package/dist/hooks/prerun/analytics.js

@@ -1,15 +1,22 @@
 import Analytics from '../../analytics.js';
 const analytics = async function (options) {
-    if (process.env.IS_HEROKU_TEST_ENV === 'true') {
+    const { isTelemetryEnabled } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
+    const { setupTelemetry } = await import('../../lib/analytics-telemetry/global-telemetry.js');
+    // Use the consolidated telemetry check
+    if (!isTelemetryEnabled()) {
         return;
     }
-    // Skip analytics on Windows for performance (unless explicitly enabled)
-    if (process.platform === 'win32' && process.env.ENABLE_WINDOWS_TELEMETRY !== 'true') {
-        return;
-    }
-    const telemetry = await import('../../global_telemetry.js');
     const globalAny = global;
-    globalAny.cliTelemetry = telemetry.setupTelemetry(this.config, options);
+    // Only setup telemetry if not already initialized (avoid overwriting init hook data)
+    if (globalAny.cliTelemetry) {
+        // Update existing telemetry for regular commands
+        globalAny.cliTelemetry.command = options.Command.id;
+        globalAny.cliTelemetry.isVersionOrHelp = false;
+        globalAny.cliTelemetry.lifecycleHookCompletion.prerun = true;
+    }
+    else {
+        globalAny.cliTelemetry = setupTelemetry(this.config, options);
+    }
     const analyticsInstance = new Analytics(this.config);
     Reflect.set(globalThis, 'recordPromise', analyticsInstance.record(options));
 };

package/dist/lib/analytics-telemetry/global-telemetry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Global telemetry orchestrator
+ * This module provides the main public API for telemetry and delegates to specialized modules
+ */
+import type { Config } from '@oclif/core/interfaces';
+import { Telemetry, TelemetryData } from './telemetry-utils.js';
+/**
+ * Options passed to telemetry setup (from oclif hooks)
+ */
+interface TelemetryOptions {
+    Command?: {
+        id: string;
+    };
+    id?: string;
+}
+/**
+ * Create telemetry object for command_not_found errors
+ */
+export declare function reportCmdNotFound(config: Config): Telemetry;
+/**
+ * Main orchestrator: Send telemetry data to appropriate destinations
+ * - Errors go to both Honeycomb and Sentry
+ * - Regular telemetry goes to Honeycomb only
+ */
+export declare function sendTelemetry(currentTelemetry: TelemetryData): Promise<void>;
+/**
+ * Create telemetry object for regular commands or version/help
+ */
+export declare function setupTelemetry(config: Config, opts: TelemetryOptions): Telemetry;
+export {};

package/dist/lib/analytics-telemetry/global-telemetry.js

@@ -0,0 +1,103 @@
+/**
+ * Global telemetry orchestrator
+ * This module provides the main public API for telemetry and delegates to specialized modules
+ */
+// Import internal dependencies
+import { sendToHoneycomb } from './honeycomb-client.js';
+import { sendToSentry } from './sentry-client.js';
+import { isTelemetryDisabled, setVersion, telemetryDebug, } from './telemetry-utils.js';
+/**
+ * Create telemetry object for command_not_found errors
+ */
+export function reportCmdNotFound(config) {
+    return {
+        cliRunDuration: 0,
+        command: 'invalid_command',
+        commandRunDuration: 0,
+        exitCode: 0,
+        exitState: 'command_not_found',
+        isTTY: process.stdin.isTTY,
+        isVersionOrHelp: false,
+        lifecycleHookCompletion: {
+            command_not_found: true,
+            init: true,
+            postrun: false,
+            prerun: false,
+        },
+        os: config.platform,
+        version: config.version,
+    };
+}
+/**
+ * Main orchestrator: Send telemetry data to appropriate destinations
+ * - Errors go to both Honeycomb and Sentry
+ * - Regular telemetry goes to Honeycomb only
+ */
+export async function sendTelemetry(currentTelemetry) {
+    if (isTelemetryDisabled) {
+        telemetryDebug('Telemetry disabled, skipping send');
+        return;
+    }
+    const telemetry = currentTelemetry;
+    if (telemetry instanceof Error) {
+        // Filter SIGINT errors from Sentry (user Ctrl+C is not an error to report)
+        // But still send to Honeycomb for analytics
+        const isSIGINT = telemetry.message === 'Received SIGINT';
+        if (isSIGINT) {
+            telemetryDebug('Sending error to Honeycomb: %s', telemetry.message);
+            await sendToHoneycomb(telemetry);
+        }
+        else {
+            telemetryDebug('Sending error to Honeycomb and Sentry: %s', telemetry.message);
+            await Promise.all([
+                sendToHoneycomb(telemetry),
+                sendToSentry(telemetry),
+            ]);
+        }
+    }
+    else {
+        telemetryDebug('Sending telemetry for command: %s', telemetry.command);
+        await sendToHoneycomb(telemetry);
+    }
+}
+/**
+ * Create telemetry object for regular commands or version/help
+ */
+export function setupTelemetry(config, opts) {
+    // Store version from config (eliminates need to read package.json)
+    setVersion(config.version);
+    const now = new Date();
+    const cmdStartTime = now.getTime();
+    const isRegularCmd = Boolean(opts.Command);
+    const mcpMode = process.env.HEROKU_MCP_MODE === 'true';
+    const mcpServerVersion = process.env.HEROKU_MCP_SERVER_VERSION || 'unknown';
+    const irregularTelemetryObject = {
+        cliRunDuration: 0,
+        command: opts.id || 'unknown',
+        commandRunDuration: cmdStartTime,
+        exitCode: 0,
+        exitState: 'successful',
+        isTTY: process.stdin.isTTY,
+        isVersionOrHelp: true,
+        lifecycleHookCompletion: {
+            command_not_found: false,
+            init: true,
+            postrun: false,
+            prerun: false,
+        },
+        os: config.platform,
+        version: `${config.version}${mcpMode ? ` (MCP ${mcpServerVersion})` : ''}`,
+    };
+    if (isRegularCmd && opts.Command) {
+        return {
+            ...irregularTelemetryObject,
+            command: opts.Command.id,
+            isVersionOrHelp: false,
+            lifecycleHookCompletion: {
+                ...irregularTelemetryObject.lifecycleHookCompletion,
+                prerun: true,
+            },
+        };
+    }
+    return irregularTelemetryObject;
+}

package/dist/lib/analytics-telemetry/honeycomb-client.d.ts

@@ -0,0 +1,15 @@
+import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { TelemetryData } from './telemetry-utils.js';
+/**
+ * Get the BatchSpanProcessor (for backward compatibility)
+ */
+export declare function getProcessor(): BatchSpanProcessor;
+/**
+ * Initialize OpenTelemetry instrumentation with Sentry context
+ * This should only be called when both OpenTelemetry and Sentry are needed together
+ */
+export declare function initializeInstrumentation(): void;
+/**
+ * Send telemetry data to Honeycomb via OpenTelemetry
+ */
+export declare function sendToHoneycomb(data: TelemetryData): Promise<void>;

package/dist/lib/analytics-telemetry/honeycomb-client.js

@@ -0,0 +1,135 @@
+import opentelemetry, { SpanStatusCode } from '@opentelemetry/api';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { Resource } from '@opentelemetry/resources';
+import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
+import * as Sentry from '@sentry/node';
+import { SentryPropagator } from '@sentry/opentelemetry';
+import debug from 'debug';
+import { getToken, getVersion, isDev, isTelemetryDisabled, telemetryDebug, } from './telemetry-utils.js';
+// Lazy-loaded state
+let isInitialized = false;
+let provider;
+let processor;
+/**
+ * Get the BatchSpanProcessor (for backward compatibility)
+ */
+export function getProcessor() {
+    ensureInitialized();
+    return processor;
+}
+/**
+ * Initialize OpenTelemetry instrumentation with Sentry context
+ * This should only be called when both OpenTelemetry and Sentry are needed together
+ */
+export function initializeInstrumentation() {
+    if (isTelemetryDisabled) {
+        return;
+    }
+    telemetryDebug('initializeInstrumentation() called - registering provider with Sentry context');
+    ensureInitialized();
+    // Note: Sentry initialization happens in sentry-client.ts
+    // This function assumes Sentry is already initialized
+    provider.register({
+        contextManager: new Sentry.SentryContextManager(),
+        propagator: new SentryPropagator(),
+    });
+    telemetryDebug('Provider registered with Sentry context manager');
+}
+/**
+ * Send telemetry data to Honeycomb via OpenTelemetry
+ */
+export async function sendToHoneycomb(data) {
+    ensureInitialized();
+    try {
+        const tracer = opentelemetry.trace.getTracer('heroku-cli', getVersion());
+        const span = tracer.startSpan('node_app_execution');
+        telemetryDebug('Created span: node_app_execution');
+        if (data instanceof Error) {
+            const errorData = data;
+            telemetryDebug('Honeycomb payload (error): %O', {
+                cliRunDuration: errorData.cliRunDuration,
+                code: errorData.code,
+                message: errorData.message,
+                name: errorData.name,
+                stack: errorData.stack,
+            });
+            span.recordException(data);
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: data.message,
+            });
+            telemetryDebug('Recorded exception in span: %s', data.message);
+        }
+        else {
+            telemetryDebug('Honeycomb payload (telemetry): %O', {
+                cliRunDuration: data.cliRunDuration,
+                command: data.command,
+                commandRunDuration: data.commandRunDuration,
+                exitCode: data.exitCode,
+                exitState: data.exitState,
+                lifecycleHookCompletion: data.lifecycleHookCompletion,
+                os: data.os,
+                version: data.version,
+            });
+            span.setAttribute('heroku_client.command', data.command);
+            span.setAttribute('heroku_client.os', data.os);
+            span.setAttribute('heroku_client.version', data.version);
+            span.setAttribute('heroku_client.exit_code', data.exitCode);
+            span.setAttribute('heroku_client.exit_state', data.exitState);
+            span.setAttribute('heroku_client.cli_run_duration', data.cliRunDuration);
+            span.setAttribute('heroku_client.command_run_duration', data.commandRunDuration);
+            span.setAttribute('heroku_client.lifecycle_hook.init', data.lifecycleHookCompletion.init);
+            span.setAttribute('heroku_client.lifecycle_hook.prerun', data.lifecycleHookCompletion.prerun);
+            span.setAttribute('heroku_client.lifecycle_hook.postrun', data.lifecycleHookCompletion.postrun);
+            span.setAttribute('heroku_client.lifecycle_hook.command_not_found', data.lifecycleHookCompletion.command_not_found);
+            telemetryDebug('Set span attributes for command: %s (duration: %dms)', data.command, data.cliRunDuration);
+        }
+        span.end();
+        telemetryDebug('Span ended, flushing to exporter...');
+        await getProcessor().forceFlush();
+        telemetryDebug('Successfully flushed telemetry to Honeycomb');
+    }
+    catch (error) {
+        telemetryDebug('Error sending telemetry to Honeycomb: %O', error);
+        debug('could not send telemetry');
+    }
+}
+/**
+ * Ensure OpenTelemetry is initialized (lazy initialization)
+ */
+function ensureInitialized() {
+    if (isInitialized || isTelemetryDisabled) {
+        return;
+    }
+    telemetryDebug('Initializing OpenTelemetry...');
+    isInitialized = true;
+    const resource = Resource
+        .default()
+        .merge(new Resource({
+        [SemanticResourceAttributes.SERVICE_NAME]: 'heroku-cli',
+        [SemanticResourceAttributes.SERVICE_VERSION]: undefined, // will be set later
+    }));
+    // Initialize without Sentry sampler initially (Sentry loaded lazily)
+    provider = new NodeTracerProvider({
+        resource,
+    });
+    telemetryDebug('NodeTracerProvider created');
+    // eslint-disable-next-line no-negated-condition, unicorn/no-negated-condition
+    const headers = { Authorization: `Bearer ${process.env.IS_HEROKU_TEST_ENV !== 'true' ? getToken() : ''}` };
+    const url = isDev ? 'https://backboard.staging.herokudev.com/otel/v1/traces' : 'https://backboard.heroku.com/otel/v1/traces';
+    telemetryDebug('OTLP exporter endpoint: %s', url);
+    const exporter = new OTLPTraceExporter({
+        compression: undefined,
+        headers,
+        url,
+    });
+    processor = new BatchSpanProcessor(exporter);
+    provider.addSpanProcessor(processor);
+    telemetryDebug('BatchSpanProcessor added to provider');
+    // Register the provider to make it the global tracer provider
+    // We don't use Sentry context manager here to avoid loading Sentry upfront
+    provider.register();
+    telemetryDebug('OpenTelemetry provider registered globally');
+}

package/dist/lib/analytics-telemetry/sentry-client.d.ts

@@ -0,0 +1,9 @@
+import { CLIError } from './telemetry-utils.js';
+/**
+ * Ensure Sentry is initialized (lazy initialization)
+ */
+export declare function ensureSentryInitialized(): void;
+/**
+ * Send error data to Sentry
+ */
+export declare function sendToSentry(data: CLIError): Promise<void>;