heroku 11.0.0-alpha.10 → 11.0.0-alpha.12

package/lib/commands/status.js

@@ -1,8 +1,7 @@
-import { color } from '@heroku-cli/color';
+import { color, hux } from '@heroku/heroku-cli-util';
+import { HTTP } from '@heroku/http-call';
 import { Command, Flags, ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
 import { formatDistanceToNow } from 'date-fns';
-import { HTTP } from '@heroku/http-call';
 import { getMaxUpdateTypeLength } from '../lib/status/util.js';
 const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 const errorMessage = 'Heroku platform status is unavailable at this time. Refer to https://status.salesforce.com/products/Heroku or try again later.';
@@ -67,27 +66,27 @@ const formatTrustResponse = (instances, activeIncidents, maintenances, localizat
     const dataIncidents = herokuActiveIncidents.filter(incident => incident.serviceKeys.includes('HerokuData') || incident.serviceKeys.includes('Data'));
     if (appsIncidents.length > 0) {
         const severity = determineIncidentSeverity(appsIncidents);
-        systemStatus.push({ system: 'Apps', status: severity });
+        systemStatus.push({ status: severity, system: 'Apps' });
         incidents.push(...appsIncidents);
     }
     else {
-        systemStatus.push({ system: 'Apps', status: 'green' });
+        systemStatus.push({ status: 'green', system: 'Apps' });
     }
     if (dataIncidents.length > 0) {
         const severity = determineIncidentSeverity(dataIncidents);
-        systemStatus.push({ system: 'Data', status: severity });
+        systemStatus.push({ status: severity, system: 'Data' });
         incidents.push(...dataIncidents);
     }
     else {
-        systemStatus.push({ system: 'Data', status: 'green' });
+        systemStatus.push({ status: 'green', system: 'Data' });
     }
     if (toolsIncidents.length > 0) {
         const severity = determineIncidentSeverity(toolsIncidents);
-        systemStatus.push({ system: 'Tools', status: severity });
+        systemStatus.push({ status: severity, system: 'Tools' });
         incidents.push(...toolsIncidents);
     }
     else {
-        systemStatus.push({ system: 'Tools', status: 'green' });
+        systemStatus.push({ status: 'green', system: 'Tools' });
     }
     if (maintenances.length > 0)
         scheduled.push(...maintenances);
@@ -98,11 +97,13 @@ const formatTrustResponse = (instances, activeIncidents, maintenances, localizat
             });
         });
     }
+    /* eslint-disable perfectionist/sort-objects */
     return {
         status: systemStatus,
         incidents,
         scheduled,
     };
+    /* eslint-enable perfectionist/sort-objects */
 };
 export default class Status extends Command {
     static description = 'display current status of the Heroku platform';
@@ -148,10 +149,10 @@ export default class Status extends Command {
         if (herokuStatus) {
             for (const incident of herokuStatus.incidents) {
                 ux.stdout();
-                hux.styledHeader(`${incident.title} ${color.yellow(incident.created_at)} ${color.cyan(incident.full_url)}`);
+                hux.styledHeader(`${incident.title} ${color.warning(incident.created_at)} ${color.info(incident.full_url)}`);
                 const padding = getMaxUpdateTypeLength(incident.updates.map(update => update.update_type));
                 for (const u of incident.updates) {
-                    ux.stdout(`${color.yellow(u.update_type.padEnd(padding))} ${new Date(u.updated_at).toISOString()} (${formatDistanceToNow(new Date(u.updated_at))} ago)`);
+                    ux.stdout(`${color.warning(u.update_type.padEnd(padding))} ${new Date(u.updated_at).toISOString()} (${formatDistanceToNow(new Date(u.updated_at))} ago)`);
                     ux.stdout(`${u.contents}\n`);
                 }
             }
@@ -159,11 +160,11 @@ export default class Status extends Command {
         else if (formattedTrustStatus) {
             for (const incident of formattedTrustStatus.incidents) {
                 ux.stdout();
-                hux.styledHeader(`${incident.id} ${color.yellow(incident.createdAt)} ${color.cyan(`https://status.salesforce.com/incidents/${incident.id}`)}`);
+                hux.styledHeader(`${incident.id} ${color.warning(incident.createdAt)} ${color.info(`https://status.salesforce.com/incidents/${incident.id}`)}`);
                 const padding = getMaxUpdateTypeLength(incident.IncidentEvents.map(event => event.localizedType ?? event.type));
                 for (const event of incident.IncidentEvents) {
                     const eventType = event.localizedType ?? event.type;
-                    ux.stdout(`${color.yellow(eventType.padEnd(padding))} ${new Date(event.createdAt).toISOString()} (${formatDistanceToNow(new Date(event.createdAt))} ago)`);
+                    ux.stdout(`${color.warning(eventType.padEnd(padding))} ${new Date(event.createdAt).toISOString()} (${formatDistanceToNow(new Date(event.createdAt))} ago)`);
                     ux.stdout(`${event.message}\n`);
                 }
             }

package/lib/commands/teams/index.d.ts

@@ -1,9 +1,9 @@
 import { Command } from '@heroku-cli/command';
 export default class Index extends Command {
-    static topic: string;
     static description: string;
     static flags: {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
+    static topic: string;
     run(): Promise<void>;
 }

package/lib/commands/teams/index.js

@@ -1,12 +1,11 @@
-import { color } from '@heroku-cli/color';
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
-import { hux } from '@heroku/heroku-cli-util';
 export default class Index extends Command {
-    static topic = 'teams';
-    static description = `list the teams that you are a member of\n\nUse ${color.cmd('heroku members:*')} to manage team members.`;
+    static description = `list the teams that you are a member of\n\nUse ${color.code('heroku members:*')} to manage team members.`;
     static flags = {
         json: flags.boolean({ description: 'output in json format' }),
     };
+    static topic = 'teams';
     async run() {
         const { flags } = await this.parse(Index);
         const { body: teams } = await this.heroku.get('/teams');
@@ -19,7 +18,7 @@ export default class Index extends Command {
                 return (aName > bName) ? 1 : ((bName > aName) ? -1 : 0);
             }), {
                 name: { header: 'Team' },
-                role: { header: 'Role', get: ({ role }) => color.green(role || '') },
+                role: { get: ({ role }) => color.info(role || ''), header: 'Role' },
             });
         }
     }

package/lib/commands/telemetry/add.d.ts

@@ -1,16 +1,17 @@
 import { Command } from '@heroku-cli/command';
 export default class Add extends Command {
+    static args: {
+        endpoint: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
     static description: string;
+    static example: string;
     static flags: {
         app: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         headers: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        space: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         signals: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        space: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         transport: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
-    static args: {
-        endpoint: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-    };
-    static example: string;
     run(): Promise<void>;
+    private getExporterType;
 }

package/lib/commands/telemetry/add.js

@@ -1,28 +1,40 @@
+import { color } from '@heroku/heroku-cli-util';
 import { Command, flags as Flags } from '@heroku-cli/command';
 import { Args, ux } from '@oclif/core';
 import tsheredoc from 'tsheredoc';
 import { validateAndFormatSignals } from '../../lib/telemetry/util.js';
 const heredoc = tsheredoc.default;
 export default class Add extends Command {
+    static args = {
+        endpoint: Args.string({ description: 'drain url', required: true }),
+    };
     static description = 'Add and configure a new telemetry drain. Defaults to collecting all telemetry unless otherwise specified.';
+    /* eslint-disable quotes */
+    static example = heredoc `
+    Add a telemetry drain to an app to collect logs and traces:
+    
+    ${color.command(`heroku telemetry:add https://my-endpoint.com --app myapp --signals logs,traces --headers '{"x-drain-example-team": "API_KEY", "x-drain-example-dataset": "METRICS_DATASET"}'`)}
+  `;
     static flags = {
-        app: Flags.string({ char: 'a', exactlyOne: ['app', 'space'], description: 'app to add a drain to' }),
+        app: Flags.string({ char: 'a', description: 'app to add a drain to', exactlyOne: ['app', 'space'] }),
         headers: Flags.string({ description: 'custom headers to configure the drain in json format' }),
-        space: Flags.string({ char: 's', description: 'space to add a drain to' }),
         signals: Flags.string({ default: 'all', description: 'comma-delimited list of signals to collect (traces, metrics, logs). Use "all" to collect all signals.' }),
-        transport: Flags.string({ default: 'http', options: ['http', 'grpc'], description: 'transport protocol for the drain' }),
-    };
-    static args = {
-        endpoint: Args.string({ required: true, description: 'drain url' }),
+        space: Flags.string({ char: 's', description: 'space to add a drain to' }),
+        // If splunk transport is accepted as a feature, this should have options: ['http', 'grpc', 'splunk']
+        transport: Flags.string({ default: 'http', description: 'transport protocol for the drain' }),
     };
-    static example = heredoc(`
-    Add a telemetry drain to an app to collect logs and traces:
-    $ heroku telemetry:add https://my-endpoint.com --app myapp --signals logs,traces --headers '{"x-drain-example-team": "API_KEY", "x-drain-example-dataset": "METRICS_DATASET"}'
-  `);
+    /* eslint-enable quotes */
     async run() {
-        const { flags, args } = await this.parse(Add);
-        const { app, headers, space, signals, transport } = flags;
+        const { args, flags } = await this.parse(Add);
+        const { app, headers, signals, space, transport } = flags;
         const { endpoint } = args;
+        // Allow splunk, but do not show splunk in error message until splunk transport is accepted as a feature
+        // When splunk transport is accepted as a feature, and options are added for the transport flag, this section should be removed
+        const publicTransports = ['http', 'grpc'];
+        const validTransports = [...publicTransports, 'splunk'];
+        if (!validTransports.includes(transport)) {
+            throw new Error(`Expected --transport=${transport} to be one of: ${publicTransports.join(', ')}`);
+        }
         let id;
         if (app) {
             const { body: herokuApp } = await this.heroku.get(`/apps/${app}`, {
@@ -36,16 +48,16 @@ export default class Add extends Command {
         }
         const exporterHeaders = headers || '{}';
         const drainConfig = {
-            owner: {
-                type: app ? 'app' : 'space',
-                id,
-            },
-            signals: validateAndFormatSignals(signals),
             exporter: {
                 endpoint,
-                type: (transport === 'grpc') ? 'otlp' : 'otlphttp',
                 headers: JSON.parse(exporterHeaders),
+                type: this.getExporterType(transport),
+            },
+            owner: {
+                id,
+                type: app ? 'app' : 'space',
             },
+            signals: validateAndFormatSignals(signals),
         };
         const { body: drain } = await this.heroku.post('/telemetry-drains', {
             body: drainConfig,
@@ -55,4 +67,17 @@ export default class Add extends Command {
         });
         ux.stdout(`successfully added drain ${drain.exporter.endpoint}`);
     }
+    getExporterType(transport) {
+        switch (transport) {
+            case 'grpc': {
+                return 'otlp';
+            }
+            case 'splunk': {
+                return 'splunk';
+            }
+            default: {
+                return 'otlphttp';
+            }
+        }
+    }
 }

package/lib/commands/telemetry/index.d.ts

@@ -1,13 +1,13 @@
 import { Command } from '@heroku-cli/command';
 import { TelemetryDrains } from '../../lib/types/telemetry.js';
 export default class Index extends Command {
-    static topic: string;
     static description: string;
+    static example: string;
     static flags: {
-        space: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         app: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        space: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    static example: string;
-    run(): Promise<void>;
+    static topic: string;
     protected display(telemetryDrains: TelemetryDrains, owner: string | undefined): void;
+    run(): Promise<void>;
 }

package/lib/commands/telemetry/index.js

@@ -1,14 +1,29 @@
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags as Flags } from '@heroku-cli/command';
 import { ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
 export default class Index extends Command {
-    static topic = 'telemetry';
     static description = 'list telemetry drains';
+    static example = `${color.command('heroku telemetry')}`;
     static flags = {
-        space: Flags.string({ char: 's', description: 'filter by space name', exactlyOne: ['app', 'space'] }),
         app: Flags.string({ char: 'a', description: 'filter by app name' }),
+        space: Flags.string({ char: 's', description: 'filter by space name', exactlyOne: ['app', 'space'] }),
     };
-    static example = '$ heroku telemetry';
+    static topic = 'telemetry';
+    display(telemetryDrains, owner) {
+        if (telemetryDrains.length === 0) {
+            ux.stdout(`There are no telemetry drains in ${owner}`);
+        }
+        else {
+            hux.styledHeader(`${owner} Telemetry Drains`);
+            /* eslint-disable perfectionist/sort-objects */
+            hux.table(telemetryDrains, {
+                ID: { get: telemetryDrain => telemetryDrain.id },
+                Signals: { get: telemetryDrain => telemetryDrain.signals },
+                Endpoint: { get: telemetryDrain => telemetryDrain.exporter.endpoint },
+            });
+            /* eslint-enable perfectionist/sort-objects */
+        }
+    }
     async run() {
         const { flags } = await this.parse(Index);
         const { app, space } = flags;
@@ -31,17 +46,4 @@ export default class Index extends Command {
         }
         this.display(drains, app || space);
     }
-    display(telemetryDrains, owner) {
-        if (telemetryDrains.length === 0) {
-            ux.stdout(`There are no telemetry drains in ${owner}`);
-        }
-        else {
-            hux.styledHeader(`${owner} Telemetry Drains`);
-            hux.table(telemetryDrains, {
-                ID: { get: telemetryDrain => telemetryDrain.id },
-                Signals: { get: telemetryDrain => telemetryDrain.signals },
-                Endpoint: { get: telemetryDrain => telemetryDrain.exporter.endpoint },
-            });
-        }
-    }
 }

package/lib/commands/telemetry/info.d.ts

@@ -1,10 +1,10 @@
 import { Command } from '@heroku-cli/command';
 export default class Info extends Command {
-    static topic: string;
-    static description: string;
     static args: {
         telemetry_drain_id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static description: string;
     static example: string;
+    static topic: string;
     run(): Promise<void>;
 }

package/lib/commands/telemetry/info.js

@@ -1,13 +1,14 @@
+import { color } from '@heroku/heroku-cli-util';
 import { Command } from '@heroku-cli/command';
 import { Args } from '@oclif/core';
 import { displayTelemetryDrain } from '../../lib/telemetry/util.js';
 export default class Info extends Command {
-    static topic = 'telemetry';
-    static description = 'show a telemetry drain\'s info';
     static args = {
-        telemetry_drain_id: Args.string({ required: true, description: 'ID of the drain to show info for' }),
+        telemetry_drain_id: Args.string({ description: 'ID of the drain to show info for', required: true }),
     };
-    static example = '$ heroku telemetry:info 022e2e2e-2e2e-2e2e-2e2e-2e2e2e2e2e2e';
+    static description = 'show a telemetry drain\'s info';
+    static example = `${color.command('heroku telemetry:info 022e2e2e-2e2e-2e2e-2e2e-2e2e2e2e2e2e')}`;
+    static topic = 'telemetry';
     async run() {
         const { args } = await this.parse(Info);
         const { telemetry_drain_id } = args;

package/lib/commands/telemetry/update.d.ts

@@ -1,16 +1,16 @@
 import { Command } from '@heroku-cli/command';
 export default class Update extends Command {
-    static topic: string;
-    static description: string;
     static args: {
         telemetry_drain_id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static description: string;
+    static example: string;
     static flags: {
         endpoint: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         headers: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         signals: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         transport: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    static example: string;
+    static topic: string;
     run(): Promise<void>;
 }

package/lib/commands/telemetry/update.js

@@ -1,23 +1,22 @@
-import { flags as Flags, Command } from '@heroku-cli/command';
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags as Flags } from '@heroku-cli/command';
 import { Args, ux } from '@oclif/core';
 import tsheredoc from 'tsheredoc';
 import { displayTelemetryDrain, validateAndFormatSignals } from '../../lib/telemetry/util.js';
 const heredoc = tsheredoc.default;
 export default class Update extends Command {
-    static topic = 'telemetry';
-    static description = 'updates a telemetry drain with provided attributes (attributes not provided remain unchanged)';
     static args = {
-        telemetry_drain_id: Args.string({ required: true, description: 'ID of the drain to update' }),
+        telemetry_drain_id: Args.string({ description: 'ID of the drain to update', required: true }),
     };
+    static description = 'updates a telemetry drain with provided attributes (attributes not provided remain unchanged)';
+    static example = `${color.command('heroku telemetry:update acde070d-8c4c-4f0d-9d8a-162843c10333 --signals logs,metrics --endpoint https://my-new-endpoint.com')}`;
     static flags = {
         endpoint: Flags.string({ description: 'drain url' }),
         headers: Flags.string({ description: 'custom headers to configure the drain in json format' }),
         signals: Flags.string({ description: 'comma-delimited list of signals to collect (traces, metrics, logs). Use "all" to collect all signals.' }),
-        transport: Flags.string({ options: ['http', 'grpc'], description: 'transport protocol for the drain' }),
+        transport: Flags.string({ description: 'transport protocol for the drain', options: ['http', 'grpc'] }),
     };
-    static example = heredoc(`
-    $ heroku telemetry:update acde070d-8c4c-4f0d-9d8a-162843c10333 --signals logs,metrics --endpoint https://my-new-endpoint.com
-  `);
+    static topic = 'telemetry';
     async run() {
         const { args, flags } = await this.parse(Update);
         const { telemetry_drain_id } = args;
@@ -47,10 +46,10 @@ export default class Update extends Command {
         }
         ux.action.start(`Updating telemetry drain ${telemetry_drain_id}`);
         const { body: telemetryDrain } = await this.heroku.patch(`/telemetry-drains/${telemetry_drain_id}`, {
+            body: drainConfig,
             headers: {
                 Accept: 'application/vnd.heroku+json; version=3.sdk',
             },
-            body: drainConfig,
         });
         ux.action.stop();
         await displayTelemetryDrain(telemetryDrain, this.heroku);

package/lib/commands/usage/addons.d.ts

@@ -1,14 +1,14 @@
 import { Command } from '@heroku-cli/command';
 export default class UsageAddons extends Command {
-    static topic: string;
     static description: string;
     static flags: {
         app: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         team: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
+    static topic: string;
+    run(): Promise<void>;
     private displayAppUsage;
     private fetchAndDisplayAppUsageData;
     private fetchAndDisplayTeamUsageData;
     private getAppInfoFromTeamAddons;
-    run(): Promise<void>;
 }

package/lib/commands/usage/addons.js

@@ -1,14 +1,26 @@
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import { ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
-import { color } from '@heroku-cli/color';
 export default class UsageAddons extends Command {
-    static topic = 'usage';
     static description = 'list usage for metered add-ons attached to an app or apps within a team';
     static flags = {
         app: flags.string({ char: 'a', description: 'app to list metered add-ons usage for' }),
         team: flags.team({ description: 'team to list metered add-ons usage for' }),
     };
+    static topic = 'usage';
+    async run() {
+        const { flags } = await this.parse(UsageAddons);
+        const { app, team } = flags;
+        if (!app && !team) {
+            ux.error('Specify an app with --app or a team with --team');
+        }
+        if (app) {
+            await this.fetchAndDisplayAppUsageData(app, team);
+        }
+        else if (team) {
+            await this.fetchAndDisplayTeamUsageData(team);
+        }
+    }
     displayAppUsage(app, usageAddons, appAddons) {
         const metersArray = usageAddons.flatMap(addon => Object.entries(addon.meters).map(([label, data]) => ({
             label,
@@ -65,7 +77,7 @@ export default class UsageAddons extends Command {
         this.displayAppUsage(app, usageAddons, appAddons);
     }
     async fetchAndDisplayTeamUsageData(team) {
-        ux.action.start(`Gathering usage data for ${color.magenta(team)}`);
+        ux.action.start(`Gathering usage data for ${color.team(team)}`);
         const [{ body: usageData }, { body: teamAddons }] = await Promise.all([
             this.heroku.get(`/teams/${team}/usage`, {
                 headers: {
@@ -77,7 +89,7 @@ export default class UsageAddons extends Command {
         ux.action.stop();
         ux.stdout();
         if (!usageData.apps || usageData.apps.length === 0) {
-            ux.stdout(`No usage found for team ${color.magenta(team)}`);
+            ux.stdout(`No usage found for team ${color.team(team)}`);
             return;
         }
         const appInfoArray = this.getAppInfoFromTeamAddons(teamAddons);
@@ -100,17 +112,4 @@ export default class UsageAddons extends Command {
             name,
         }));
     }
-    async run() {
-        const { flags } = await this.parse(UsageAddons);
-        const { app, team } = flags;
-        if (!app && !team) {
-            ux.error('Specify an app with --app or a team with --team');
-        }
-        if (app) {
-            await this.fetchAndDisplayAppUsageData(app, team);
-        }
-        else if (team) {
-            await this.fetchAndDisplayTeamUsageData(team);
-        }
-    }
 }

package/lib/global_telemetry.d.ts

@@ -56,7 +56,7 @@ export declare function reportCmdNotFound(config: any): {
     };
     isVersionOrHelp: boolean;
 };
-export declare function sendTelemetry(currentTelemetry: any, rollbarCb?: () => void): Promise<void>;
+export declare function sendTelemetry(currentTelemetry: any): Promise<void>;
 export declare function sendToHoneycomb(data: Telemetry | CLIError): Promise<void>;
-export declare function sendToRollbar(data: CLIError, rollbarCb?: () => void): Promise<unknown>;
+export declare function sendToSentry(data: CLIError): Promise<void>;
 export {};

package/lib/global_telemetry.js

@@ -1,7 +1,11 @@
-import Rollbar from 'rollbar';
 import { APIClient } from '@heroku-cli/command';
 import { Config } from '@oclif/core';
 import opentelemetry, { SpanStatusCode } from '@opentelemetry/api';
+import * as Sentry from '@sentry/node';
+import { SentryPropagator, SentrySampler, } from '@sentry/opentelemetry';
+import { GDPR_FIELDS, HEROKU_FIELDS, PCI_FIELDS } from './lib/data-scrubber/presets.js';
+import { Scrubber } from './lib/data-scrubber/scrubber.js';
+import { PII_PATTERNS } from './lib/data-scrubber/patterns.js';
 import { Resource } from '@opentelemetry/resources';
 import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
@@ -21,21 +25,29 @@ async function getVersion() {
     const pkg = JSON.parse(await fs.readFile(root, 'utf8'));
     return pkg.version;
 }
+const version = await getVersion();
 function getToken() {
     const config = new Config({ root });
     const heroku = new APIClient(config);
     return heroku.auth;
 }
-const rollbar = new Rollbar({
-    accessToken: '20783109b0064dbb85be0b2c5a5a5f79',
-    captureUncaught: true,
-    captureUnhandledRejections: true,
-    environment: isDev ? 'development' : 'production',
-    codeVersion: undefined, // will be set later
-});
 registerInstrumentations({
     instrumentations: [],
 });
+const scrubber = new Scrubber({
+    fields: [...HEROKU_FIELDS, ...GDPR_FIELDS, ...PCI_FIELDS],
+    patterns: [...PII_PATTERNS],
+});
+const sentryClient = Sentry.init({
+    dsn: 'https://76530569188e7ee2961373f37951d916@o4508609692368896.ingest.us.sentry.io/4508767754846208',
+    environment: isDev ? 'development' : 'production',
+    release: version,
+    tracesSampleRate: 1,
+    beforeSend(event) {
+        return scrubber.scrub(event).data;
+    },
+    skipOpenTelemetrySetup: true, // needed since we have our own OTEL setup
+});
 const resource = Resource
     .default()
     .merge(new Resource({
@@ -44,6 +56,7 @@ const resource = Resource
 }));
 const provider = new NodeTracerProvider({
     resource,
+    sampler: sentryClient ? new SentrySampler(sentryClient) : undefined,
 });
 // eslint-disable-next-line no-negated-condition, unicorn/no-negated-condition
 const headers = { Authorization: `Bearer ${process.env.IS_HEROKU_TEST_ENV !== 'true' ? getToken() : ''}` };
@@ -55,7 +68,11 @@ const exporter = new OTLPTraceExporter({
 export const processor = new BatchSpanProcessor(exporter);
 provider.addSpanProcessor(processor);
 export function initializeInstrumentation() {
-    provider.register();
+    provider.register({
+        propagator: new SentryPropagator(),
+        contextManager: new Sentry.SentryContextManager(),
+    });
+    // provider.register()
 }
 export function setupTelemetry(config, opts) {
     const now = new Date();
@@ -116,16 +133,16 @@ export function reportCmdNotFound(config) {
         isVersionOrHelp: false,
     };
 }
-export async function sendTelemetry(currentTelemetry, rollbarCb) {
-    // send telemetry to honeycomb and rollbar
+export async function sendTelemetry(currentTelemetry) {
+    // send telemetry to honeycomb
     if (isTelemetryDisabled) {
         return;
     }
     const telemetry = currentTelemetry;
     if (telemetry instanceof Error) {
         await Promise.all([
-            sendToRollbar(telemetry, rollbarCb),
             sendToHoneycomb(telemetry),
+            sendToSentry(telemetry),
         ]);
     }
     else {
@@ -134,7 +151,6 @@ export async function sendTelemetry(currentTelemetry, rollbarCb) {
 }
 export async function sendToHoneycomb(data) {
     try {
-        const version = await getVersion();
         const tracer = opentelemetry.trace.getTracer('heroku-cli', version);
         const span = tracer.startSpan('node_app_execution');
         if (data instanceof Error) {
@@ -158,37 +174,19 @@ export async function sendToHoneycomb(data) {
             span.setAttribute('heroku_client.lifecycle_hook.command_not_found', data.lifecycleHookCompletion.command_not_found);
         }
         span.end();
-        processor.forceFlush();
+        await processor.forceFlush();
     }
     catch {
         debug('could not send telemetry');
     }
 }
-export async function sendToRollbar(data, rollbarCb) {
-    // Make this awaitable so we can wait for it to finish before exiting
-    let promiseResolve;
-    const rollbarPromise = new Promise((resolve, reject) => {
-        promiseResolve = () => {
-            if (rollbarCb) {
-                try {
-                    rollbarCb();
-                }
-                catch (error) {
-                    reject(error);
-                }
-            }
-            resolve(null);
-        };
-    });
-    const rollbarError = { name: data.name, message: data.message, stack: data.stack, cli_run_duration: data.cliRunDuration };
+export async function sendToSentry(data) {
     try {
-        // send data to rollbar
-        rollbar.error('Failed to complete execution', rollbarError, promiseResolve);
+        Sentry.captureException(data);
+        // ensures all events are sent to Sentry before exiting.
+        await Sentry.flush();
     }
     catch {
         debug('Could not send error report');
-        // eslint-disable-next-line unicorn/no-useless-promise-resolve-reject
-        return Promise.reject();
     }
-    return rollbarPromise;
 }

package/lib/lib/addons/addons_wait.d.ts

@@ -1,5 +1,5 @@
-import * as Heroku from '@heroku-cli/schema';
 import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
 export declare const waitForAddonProvisioning: (api: APIClient, addon: Heroku.AddOn, interval: number) => Promise<{
     [x: string]: any;
     actions?: {