heroku 11.2.0 → 11.3.0-beta.0

package/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
 
+## [11.3.0-beta.0](https://github.com/heroku/cli/compare/v11.2.0...v11.3.0-beta.0) (2026-04-14)
+
+
+### Features
+
+* adds 'data:pg:upgrade:run/wait' commands (W-21304392) ([#3551](https://github.com/heroku/cli/issues/3551)) ([3297c5e](https://github.com/heroku/cli/commit/3297c5e218fe9105cd106000cba030e784d17a82))
+
+
+### Bug Fixes
+
+* restore beforeExit handler for version commands and add comprehensive telemetry debug logging ([#3657](https://github.com/heroku/cli/issues/3657)) ([6da79cd](https://github.com/heroku/cli/commit/6da79cd4686133e1ee1f92b59127d8e012739b99))
+
+
+### Miscellaneous Chores
+
+* remove @oclif/plugin-legacy dependency ([#3659](https://github.com/heroku/cli/issues/3659)) ([2523d48](https://github.com/heroku/cli/commit/2523d481a79f0d26ab8b6897c6b49d3e5713a218))
+
 ## [11.2.0](https://github.com/heroku/cli/compare/v11.1.1...v11.2.0) (2026-04-08)
 
 

package/bin/run.js

@@ -12,9 +12,11 @@ process.env.HEROKU_UPDATE_INSTRUCTIONS = process.env.HEROKU_UPDATE_INSTRUCTIONS
 const now = new Date()
 const cliStartTime = now.getTime()
 
-const {isTelemetryEnabled} = await import('../dist/lib/analytics-telemetry/telemetry-utils.js')
+const {isTelemetryEnabled, getTelemetryDisabledReason, telemetryDebug} = await import('../dist/lib/analytics-telemetry/telemetry-utils.js')
+const enableTelemetry = isTelemetryEnabled()
 
-if (isTelemetryEnabled()) {
+if (enableTelemetry) {
+  telemetryDebug('Telemetry enabled: setting up handlers (beforeExit, SIGINT, SIGTERM)')
   // 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')
@@ -23,8 +25,11 @@ if (isTelemetryEnabled()) {
   setupTelemetryHandlers({
     cliStartTime,
     computeDuration,
-    enableTelemetry: isTelemetryEnabled(),
+    enableTelemetry,
   })
+} else {
+  const reason = getTelemetryDisabledReason()
+  telemetryDebug('Telemetry disabled (%s): skipping telemetry handler setup', reason)
 }
 
 await execute({dir: import.meta.url})

package/dist/commands/data/pg/upgrade/run.d.ts

@@ -0,0 +1,15 @@
+import BaseCommand from '../../../../lib/data/baseCommand.js';
+export default class DataPgUpgradeRun extends BaseCommand {
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        version: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/data/pg/upgrade/run.js

@@ -0,0 +1,58 @@
+import { flags as Flags } from '@heroku-cli/command';
+import { color, hux, utils } from '@heroku/heroku-cli-util';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import BaseCommand from '../../../../lib/data/baseCommand.js';
+const heredoc = tsheredoc.default;
+export default class DataPgUpgradeRun extends BaseCommand {
+    static args = {
+        database: Args.string({
+            description: 'database name, database attachment name, or related config var on an app',
+            required: true,
+        }),
+    };
+    static description = 'upgrade the Postgres version on a Postgres Advanced database';
+    static examples = [
+        heredoc `
+      # Upgrade a Postgres Advanced database to version 17
+      ${color.code('<%= config.bin %> <%= command.id %> DATABASE --version 17 --app my-app')}
+    `,
+    ];
+    static flags = {
+        app: Flags.app({ required: true }),
+        confirm: Flags.string({ char: 'c', description: 'pass in the app name to skip confirmation prompts' }),
+        remote: Flags.remote(),
+        version: Flags.string({ char: 'v', description: 'Postgres version to upgrade to' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(DataPgUpgradeRun);
+        const { app, confirm, version } = flags;
+        const { database } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon } = await dbResolver.getAttachment(app, database);
+        if (!utils.pg.isAdvancedDatabase(addon)) {
+            ux.error('You can only use this command on Advanced-tier databases.\n'
+                + `Use ${color.code(`heroku pg:upgrade:run ${addon.name} --app ${app}`)} instead.`);
+        }
+        const { body: databaseInfo } = await this.dataApi.get(`/data/postgres/v1/${addon.id}/info`);
+        const { version: currentVersion } = databaseInfo;
+        const newVersion = version ?? 'the latest supported Postgres version';
+        await hux.confirmCommand({
+            comparison: app,
+            confirmation: confirm,
+            warningMessage: heredoc(`
+        This command immediately upgrades your ${color.datastore(addon.name)} database from ${currentVersion} to ${newVersion}.
+        Your database will be unavailable until the upgrade is complete.`),
+        });
+        try {
+            ux.action.start(`Upgrading your ${color.datastore(addon.name)} database from ${currentVersion} to ${newVersion}`);
+            await this.dataApi.post(`/data/postgres/v1/${addon.id}/upgrade/run`, { body: { version } });
+            ux.action.stop();
+            ux.stderr(`Upgrade started. Use ${color.code(`heroku data:pg:upgrade:wait ${addon.name} -a ${app}`)} to monitor progress.`);
+        }
+        catch (error) {
+            ux.action.stop(color.red('!'));
+            throw error;
+        }
+    }
+}

package/dist/commands/data/pg/upgrade/wait.d.ts

@@ -0,0 +1,6 @@
+import DataPgWait from '../wait.js';
+export default class DataPgUpgradeWait extends DataPgWait {
+    static description: string;
+    static examples: string[];
+    protected classicWaitCommand: string;
+}

package/dist/commands/data/pg/upgrade/wait.js

@@ -0,0 +1,18 @@
+import * as color from '@heroku/heroku-cli-util/color';
+import tsheredoc from 'tsheredoc';
+import DataPgWait from '../wait.js';
+const heredoc = tsheredoc.default;
+export default class DataPgUpgradeWait extends DataPgWait {
+    static description = 'shows status of an upgrade until it\'s complete';
+    static examples = [
+        heredoc(`
+      # Wait for upgrade to complete
+      ${color.code('<%= config.bin %> <%= command.id %> DATABASE --app myapp')}
+    `),
+        heredoc(`
+      # Wait with custom polling interval (to avoid rate limiting)
+      ${color.code('<%= config.bin %> <%= command.id %> DATABASE --app myapp --wait-interval 10')}
+    `),
+    ];
+    classicWaitCommand = 'pg:upgrade:wait';
+}

package/dist/commands/data/pg/wait.d.ts

@@ -12,6 +12,7 @@ export default class DataPgWait extends BaseCommand {
         remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'wait-interval': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
     };
+    protected classicWaitCommand: string;
     notify(...args: Parameters<typeof notify>): Promise<void>;
     run(): Promise<void>;
     wait(ms: number): Promise<void>;

package/dist/commands/data/pg/wait.js

@@ -1,5 +1,6 @@
-import { color, utils } from '@heroku/heroku-cli-util';
 import { flags as Flags } from '@heroku-cli/command';
+import * as color from '@heroku/heroku-cli-util/color';
+import { DatabaseResolver, isAdvancedDatabase } from '@heroku/heroku-cli-util/utils';
 import { Args, ux } from '@oclif/core';
 import tsheredoc from 'tsheredoc';
 import BaseCommand from '../../../lib/data/baseCommand.js';
@@ -16,7 +17,7 @@ export default class DataPgWait extends BaseCommand {
     static examples = [
         heredoc(`
       # Wait for database to be available
-      ${color.command('heroku data:pg:wait DATABASE --app myapp')}
+      ${color.code('<%= config.bin %> <%= command.id %> DATABASE --app myapp')}
     `),
     ];
     static flags = {
@@ -31,6 +32,7 @@ export default class DataPgWait extends BaseCommand {
             min: 1,
         }),
     };
+    classicWaitCommand = 'pg:wait';
     async notify(...args) {
         return notify(...args);
     }
@@ -38,13 +40,13 @@ export default class DataPgWait extends BaseCommand {
         const { args, flags } = await this.parse(DataPgWait);
         const { database } = args;
         const { app, 'no-notify': noNotify, 'wait-interval': waitInterval } = flags;
-        const databaseResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const databaseResolver = new DatabaseResolver(this.heroku);
         const db = await databaseResolver.getAttachment(app, database);
         const { addon } = db;
-        if (!utils.pg.isAdvancedDatabase(addon)) {
+        if (!isAdvancedDatabase(addon)) {
             ux.error(heredoc `
         You can only use this command on Advanced-tier databases.
-        Run ${color.code(`heroku pg:wait ${addon.name} -a ${app}`)} instead.`);
+        Use ${color.code(`heroku ${this.classicWaitCommand} ${addon.name} -a ${app}`)} instead.`);
         }
         await this.waitFor(addon, waitInterval || 5, noNotify);
     }

package/dist/hooks/command_not_found/setup-otel-telemetry.js

@@ -1,9 +1,12 @@
 const performance_analytics = async function () {
-    const { isTelemetryEnabled } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
+    const { isTelemetryEnabled, getTelemetryDisabledReason, telemetryDebug } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
     // Use the consolidated telemetry check
     if (!isTelemetryEnabled()) {
+        const reason = getTelemetryDisabledReason();
+        telemetryDebug('Telemetry disabled (%s): skipping command_not_found hook, not setting up telemetry for invalid command', reason);
         return;
     }
+    telemetryDebug('Telemetry enabled: command_not_found hook setting up telemetry for invalid command');
     const { telemetryManager } = await import('../../lib/analytics-telemetry/telemetry-manager.js');
     const globalAny = global;
     globalAny.cliTelemetry = telemetryManager.reportCmdNotFound(this.config);

package/dist/hooks/finally/send-otel-and-sentry-errors.js

@@ -31,11 +31,14 @@ const finallyHook = async function (options) {
     if (isUserError(options.error)) {
         return;
     }
-    const { isTelemetryEnabled, spawnTelemetryWorker } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
+    const { isTelemetryEnabled, getTelemetryDisabledReason, spawnTelemetryWorker, telemetryDebug } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
     // Use the consolidated telemetry check
     if (!isTelemetryEnabled()) {
+        const reason = getTelemetryDisabledReason();
+        telemetryDebug('Telemetry disabled (%s): skipping finally hook, not sending error: %s', reason, options.error.message);
         return;
     }
+    telemetryDebug('Telemetry enabled: finally hook spawning worker to send error: %s', options.error.message);
     // Spawn background process to send error without blocking
     spawnTelemetryWorker(options.error);
 };

package/dist/hooks/init/setup-otel-telemetry.js

@@ -1,9 +1,12 @@
 const performance_analytics = async function (options) {
-    const { isTelemetryEnabled } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
+    const { isTelemetryEnabled, getTelemetryDisabledReason, telemetryDebug } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
     // Use the consolidated telemetry check
     if (!isTelemetryEnabled()) {
+        const reason = getTelemetryDisabledReason();
+        telemetryDebug('Telemetry disabled (%s): skipping init hook, not setting up telemetry object', reason);
         return;
     }
+    telemetryDebug('Telemetry enabled: init hook setting up telemetry object for command');
     const { telemetryManager } = await import('../../lib/analytics-telemetry/telemetry-manager.js');
     const globalAny = global;
     globalAny.cliTelemetry = telemetryManager.setupTelemetry(this.config, options);

package/dist/hooks/postrun/send-otel-telemetry.js

@@ -3,15 +3,20 @@ const performance_analytics = async function () {
     if (!globalAny.cliTelemetry) {
         return;
     }
-    const { computeDuration, isTelemetryEnabled, spawnTelemetryWorker } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
+    const { computeDuration, isTelemetryEnabled, getTelemetryDisabledReason, spawnTelemetryWorker, telemetryDebug } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
     // Use the consolidated telemetry check
     if (!isTelemetryEnabled()) {
+        const reason = getTelemetryDisabledReason();
+        telemetryDebug('Telemetry disabled (%s): skipping postrun hook, not sending telemetry for command: %s', reason, globalAny.cliTelemetry.command);
         return;
     }
+    telemetryDebug('Telemetry enabled: postrun hook spawning worker to send telemetry for command: %s', globalAny.cliTelemetry.command);
     const cmdStartTime = globalAny.cliTelemetry.commandRunDuration;
     globalAny.cliTelemetry.commandRunDuration = computeDuration(cmdStartTime);
     globalAny.cliTelemetry.lifecycleHookCompletion.postrun = true;
     // Spawn background process to send telemetry without blocking
     spawnTelemetryWorker(globalAny.cliTelemetry);
+    // Mark telemetry as sent to prevent duplicate sends from beforeExit handler
+    globalAny.telemetrySent = true;
 };
 export default performance_analytics;

package/dist/hooks/prerun/collect-and-send-herokulytics.js

@@ -1,9 +1,12 @@
 const analytics = async function (options) {
-    const { isTelemetryEnabled, spawnTelemetryWorker } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
+    const { isTelemetryEnabled, getTelemetryDisabledReason, spawnTelemetryWorker, telemetryDebug } = await import('../../lib/analytics-telemetry/telemetry-utils.js');
     // Use the consolidated telemetry check
     if (!isTelemetryEnabled()) {
+        const reason = getTelemetryDisabledReason();
+        telemetryDebug('Telemetry disabled (%s): skipping prerun hook, not sending Herokulytics for command: %s', reason, options.Command.id);
         return;
     }
+    telemetryDebug('Telemetry enabled: prerun hook spawning worker to send Herokulytics for command: %s', options.Command.id);
     const { telemetryManager } = await import('../../lib/analytics-telemetry/telemetry-manager.js');
     const globalAny = global;
     // Only setup telemetry if not already initialized (avoid overwriting init hook data)

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

@@ -40,7 +40,6 @@ class TelemetryManager {
      */
     async sendTelemetry(currentTelemetry) {
         if (!isTelemetryEnabled()) {
-            telemetryDebug('Telemetry disabled, skipping send');
             return;
         }
         const { backboardOtelClient, sentryClient } = await this.getClients();

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

@@ -48,12 +48,17 @@ export interface Telemetry {
 export type TelemetryData = CLIError | Telemetry;
 export interface TelemetryGlobal {
     cliTelemetry?: Telemetry;
+    telemetrySent?: boolean;
 }
 export type WorkerData = HerokulyticsData | TelemetryData;
 /**
  * Compute duration from a start time to now
  */
 export declare function computeDuration(cmdStartTime: number): number;
+/**
+ * Get the reason why telemetry is disabled (for logging purposes)
+ */
+export declare function getTelemetryDisabledReason(): null | string;
 /**
  * Get authentication token, cached to avoid recreating Config/APIClient
  * Lazy-loads @heroku-cli/command and @oclif/core/config to avoid loading them during CLI init
@@ -65,6 +70,7 @@ export declare function getToken(): Promise<string | undefined>;
 export declare function getVersion(): string;
 /**
  * Check if telemetry is enabled based on environment variables
+ * Returns both the enabled status and a reason string for logging
  */
 export declare function isTelemetryEnabled(): boolean;
 /**

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

@@ -21,6 +21,21 @@ export function computeDuration(cmdStartTime) {
     const cmdFinishTime = now.getTime();
     return cmdFinishTime - cmdStartTime;
 }
+/**
+ * Get the reason why telemetry is disabled (for logging purposes)
+ */
+export function getTelemetryDisabledReason() {
+    if (process.env.DISABLE_TELEMETRY === 'true') {
+        return 'DISABLE_TELEMETRY=true';
+    }
+    if (process.platform === 'win32' && process.env.ENABLE_WINDOWS_TELEMETRY !== 'true') {
+        return 'Windows platform requires ENABLE_WINDOWS_TELEMETRY=true';
+    }
+    if (process.env.IS_HEROKU_TEST_ENV === 'true') {
+        return 'IS_HEROKU_TEST_ENV=true';
+    }
+    return null;
+}
 /**
  * Get authentication token, cached to avoid recreating Config/APIClient
  * Lazy-loads @heroku-cli/command and @oclif/core/config to avoid loading them during CLI init
@@ -53,14 +68,18 @@ export function getVersion() {
 }
 /**
  * Check if telemetry is enabled based on environment variables
+ * Returns both the enabled status and a reason string for logging
  */
 export function isTelemetryEnabled() {
-    if (process.env.DISABLE_TELEMETRY === 'true')
+    if (process.env.DISABLE_TELEMETRY === 'true') {
         return false;
-    if (process.platform === 'win32' && process.env.ENABLE_WINDOWS_TELEMETRY !== 'true')
+    }
+    if (process.platform === 'win32' && process.env.ENABLE_WINDOWS_TELEMETRY !== 'true') {
         return false;
-    if (process.env.IS_HEROKU_TEST_ENV === 'true')
+    }
+    if (process.env.IS_HEROKU_TEST_ENV === 'true') {
         return false;
+    }
     return true;
 }
 /**

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

@@ -1,6 +1,7 @@
 import { TelemetryGlobal } from './telemetry-utils.js';
 declare global {
     var cliTelemetry: TelemetryGlobal['cliTelemetry'];
+    var telemetrySent: TelemetryGlobal['telemetrySent'];
 }
 interface SetupTelemetryOptions {
     cliStartTime: number;
@@ -8,9 +9,10 @@ interface SetupTelemetryOptions {
     enableTelemetry: boolean;
 }
 /**
- * Setup telemetry handlers for signal handlers
- * Note: Normal command completion telemetry is handled by the postrun hook.
- * This only handles SIGINT/SIGTERM cases where hooks don't run.
+ * Setup telemetry handlers for beforeExit and signal handlers
+ * - beforeExit: Fallback for commands where postrun hook doesn't run (e.g., version, --help flags)
+ * - postrun hook: Handles regular commands (sets telemetrySent flag to prevent duplicates)
+ * - SIGINT/SIGTERM: Handles interrupted commands
  */
 export declare function setupTelemetryHandlers(options: SetupTelemetryOptions): void;
 export {};

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

@@ -1,16 +1,30 @@
 /* eslint-disable n/no-process-exit */
-import { spawnTelemetryWorker } from './telemetry-utils.js';
+/* eslint-disable no-var */
+import { spawnTelemetryWorker, telemetryDebug, } from './telemetry-utils.js';
 /**
- * Setup telemetry handlers for signal handlers
- * Note: Normal command completion telemetry is handled by the postrun hook.
- * This only handles SIGINT/SIGTERM cases where hooks don't run.
+ * Setup telemetry handlers for beforeExit and signal handlers
+ * - beforeExit: Fallback for commands where postrun hook doesn't run (e.g., version, --help flags)
+ * - postrun hook: Handles regular commands (sets telemetrySent flag to prevent duplicates)
+ * - SIGINT/SIGTERM: Handles interrupted commands
  */
 export function setupTelemetryHandlers(options) {
     const { cliStartTime, computeDuration, enableTelemetry } = options;
     if (!enableTelemetry)
         return;
-    // Note: beforeExit handler removed to avoid duplicate telemetry sends.
-    // The postrun hook now handles normal command completion telemetry.
+    // Fallback handler for commands that don't trigger postrun hook
+    // (e.g., version, --version, --help flags handled by oclif)
+    process.once('beforeExit', code => {
+        // Only send if telemetry wasn't already sent by postrun hook
+        if (global.cliTelemetry && !global.telemetrySent) {
+            telemetryDebug('Telemetry enabled: beforeExit spawning worker to send telemetry for command: %s (postrun did not run)', global.cliTelemetry.command);
+            const cmdStartTime = global.cliTelemetry.commandRunDuration;
+            global.cliTelemetry.commandRunDuration = computeDuration(cmdStartTime);
+            global.cliTelemetry.exitCode = code;
+            global.cliTelemetry.cliRunDuration = computeDuration(cliStartTime);
+            spawnTelemetryWorker(global.cliTelemetry);
+            global.telemetrySent = true;
+        }
+    });
     process.on('SIGINT', () => {
         // Spawn background process to send telemetry
         const error = Object.assign(new Error('Received SIGINT'), {