heroku 8.2.0 → 8.3.0

package/README.md

@@ -56,13 +56,16 @@ For other issues, [submit a support ticket](https://help.heroku.com/).
 * [`heroku logs`](docs/logs.md) - display recent log output
 * [`heroku maintenance`](docs/maintenance.md) - enable/disable access to app
 * [`heroku members`](docs/members.md) - manage organization members
+* [`heroku notifications`](docs/notifications.md) - display notifications
 * [`heroku orgs`](docs/orgs.md) - manage organizations
 * [`heroku pg`](docs/pg.md) - manage postgresql databases
 * [`heroku pipelines`](docs/pipelines.md) - list pipelines you have access to
 * [`heroku plugins`](docs/plugins.md) - List installed plugins.
 * [`heroku ps`](docs/ps.md) - Client tools for Heroku Exec
+* [`heroku psql`](docs/psql.md) - open a psql shell to the database
 * [`heroku redis`](docs/redis.md) - manage heroku redis instances
 * [`heroku regions`](docs/regions.md) - list available regions for deployment
+* [`heroku releases`](docs/releases.md) - display the releases for an app
 * [`heroku reviewapps`](docs/reviewapps.md) - disable review apps and/or settings on an existing pipeline
 * [`heroku run`](docs/run.md) - run a one-off process inside a Heroku dyno
 * [`heroku sessions`](docs/sessions.md) - OAuth sessions

package/bin/run

@@ -10,6 +10,11 @@ const globalTelemetry = require('../lib/global_telemetry')
 
 process.once('beforeExit', async code => {
   // capture as successful exit
+  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
@@ -18,23 +23,27 @@ process.once('beforeExit', async code => {
 
 process.on('SIGINT', async () => {
   // capture as unsuccessful exit
-  let error = new Error('Received SIGINT')
+  const error = new Error('Received SIGINT')
   error.cliRunDuration = globalTelemetry.computeDuration(cliStartTime)
   await globalTelemetry.sendTelemetry(error)
+  process.exit(1)
 })
 
 process.on('SIGTERM', async () => {
   // capture as unsuccessful exit
-  let error = new Error('Received SIGTERM')
+  const error = new Error('Received SIGTERM')
   error.cliRunDuration = globalTelemetry.computeDuration(cliStartTime)
   await globalTelemetry.sendTelemetry(error)
+  process.exit(1)
 })
 
+globalTelemetry.initializeInstrumentation()
+
 const oclif = require('@oclif/core')
 
 oclif.run().then(require('@oclif/core/flush')).catch(async error => {
   // capture any errors raised by oclif
-  let cliError = error
+  const cliError = error
   cliError.cliRunDuration = globalTelemetry.computeDuration(cliStartTime)
   await globalTelemetry.sendTelemetry(cliError)
   console.log(`Error: ${error.message}`)

package/lib/global_telemetry.d.ts

@@ -1,10 +1,11 @@
 import 'dotenv/config';
+export declare const processor: any;
 interface Telemetry {
     command: string;
     os: string;
     version: string;
     exitCode: number;
-    exitState: string[];
+    exitState: string;
     cliRunDuration: number;
     commandRunDuration: number;
     lifecycleHookCompletion: {
@@ -13,16 +14,21 @@ interface Telemetry {
         postrun: boolean;
         command_not_found: boolean;
     };
+    isVersionOrHelp: boolean;
 }
 export interface TelemetryGlobal extends NodeJS.Global {
     cliTelemetry?: Telemetry;
 }
+interface CLIError extends Error {
+    cliRunDuration?: string;
+}
+export declare function initializeInstrumentation(): void;
 export declare function setupTelemetry(config: any, opts: any): {
     command: any;
     os: any;
     version: any;
     exitCode: number;
-    exitState: string[];
+    exitState: string;
     cliRunDuration: number;
     commandRunDuration: number;
     lifecycleHookCompletion: {
@@ -31,14 +37,15 @@ export declare function setupTelemetry(config: any, opts: any): {
         postrun: boolean;
         command_not_found: boolean;
     };
-};
+    isVersionOrHelp: boolean;
+} | undefined;
 export declare function computeDuration(cmdStartTime: any): number;
 export declare function reportCmdNotFound(config: any): {
     command: string;
     os: any;
     version: any;
     exitCode: number;
-    exitState: string[];
+    exitState: string;
     cliRunDuration: number;
     commandRunDuration: number;
     lifecycleHookCompletion: {
@@ -47,7 +54,9 @@ export declare function reportCmdNotFound(config: any): {
         postrun: boolean;
         command_not_found: boolean;
     };
+    isVersionOrHelp: boolean;
 };
-export declare function sendTelemetry(currentTelemetry: any): Promise<void>;
-export declare function sendToRollbar(data: any): Promise<void>;
+export declare function sendTelemetry(currentTelemetry: any, rollbarCb?: () => void): Promise<void>;
+export declare function sendToHoneycomb(data: Telemetry | CLIError): Promise<void>;
+export declare function sendToRollbar(data: CLIError, rollbarCb?: () => void): Promise<unknown>;
 export {};

package/lib/global_telemetry.js

@@ -1,9 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendToRollbar = exports.sendTelemetry = exports.reportCmdNotFound = exports.computeDuration = exports.setupTelemetry = void 0;
-const Rollbar = require("rollbar");
+exports.sendToRollbar = exports.sendToHoneycomb = exports.sendTelemetry = exports.reportCmdNotFound = exports.computeDuration = exports.setupTelemetry = exports.initializeInstrumentation = exports.processor = void 0;
 require("dotenv/config");
+const Rollbar = require("rollbar");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const api_1 = require("@opentelemetry/api");
+const { Resource } = require('@opentelemetry/resources');
+const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
+const { registerInstrumentations } = require('@opentelemetry/instrumentation');
+const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
+const { BatchSpanProcessor } = require('@opentelemetry/sdk-trace-base');
+const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
+const { version } = require('../../../packages/cli/package.json');
 const isDev = process.env.IS_DEV_ENVIRONMENT === 'true';
+const path = require('path');
+const root = path.resolve(__dirname, '../../../package.json');
+const config = new core_1.Config({ root });
+const heroku = new command_1.APIClient(config);
+const token = heroku.auth;
 const debug = require('debug')('global_telemetry');
 const rollbar = new Rollbar({
     accessToken: '41f8730238814af69c248e2f7ca59ff2',
@@ -11,24 +26,71 @@ const rollbar = new Rollbar({
     captureUnhandledRejections: true,
     environment: isDev ? 'development' : 'production',
 });
+registerInstrumentations({
+    instrumentations: [],
+});
+const resource = Resource
+    .default()
+    .merge(new Resource({
+    [SemanticResourceAttributes.SERVICE_NAME]: 'heroku-cli',
+    [SemanticResourceAttributes.SERVICE_VERSION]: version,
+}));
+const provider = new NodeTracerProvider({
+    resource,
+});
+const headers = { Authorization: `Bearer ${token}` };
+const exporter = new OTLPTraceExporter({
+    url: isDev ? 'https://backboard-staging.herokuapp.com/otel/v1/traces' : 'https://backboard.heroku.com/otel/v1/traces',
+    headers,
+    compression: 'none',
+});
+exports.processor = new BatchSpanProcessor(exporter);
+provider.addSpanProcessor(exports.processor);
+function initializeInstrumentation() {
+    provider.register();
+}
+exports.initializeInstrumentation = initializeInstrumentation;
 function setupTelemetry(config, opts) {
     const now = new Date();
     const cmdStartTime = now.getTime();
-    return {
-        command: opts.Command.id,
-        os: config.platform,
-        version: config.version,
-        exitCode: 0,
-        exitState: [''],
-        cliRunDuration: 0,
-        commandRunDuration: cmdStartTime,
-        lifecycleHookCompletion: {
-            init: true,
-            prerun: true,
-            postrun: false,
-            command_not_found: false,
-        },
-    };
+    const isHelpOrVersionCmd = (opts.id === 'version' || opts.id === '--help');
+    const isRegularCmd = Boolean(opts.Command);
+    if (isHelpOrVersionCmd) {
+        return {
+            command: opts.id,
+            os: config.platform,
+            version: config.version,
+            exitCode: 0,
+            exitState: 'successful',
+            cliRunDuration: 0,
+            commandRunDuration: cmdStartTime,
+            lifecycleHookCompletion: {
+                init: true,
+                prerun: false,
+                postrun: false,
+                command_not_found: false,
+            },
+            isVersionOrHelp: true,
+        };
+    }
+    if (isRegularCmd) {
+        return {
+            command: opts.Command.id,
+            os: config.platform,
+            version: config.version,
+            exitCode: 0,
+            exitState: 'successful',
+            cliRunDuration: 0,
+            commandRunDuration: cmdStartTime,
+            lifecycleHookCompletion: {
+                init: true,
+                prerun: true,
+                postrun: false,
+                command_not_found: false,
+            },
+            isVersionOrHelp: false,
+        };
+    }
 }
 exports.setupTelemetry = setupTelemetry;
 function computeDuration(cmdStartTime) {
@@ -40,11 +102,11 @@ function computeDuration(cmdStartTime) {
 exports.computeDuration = computeDuration;
 function reportCmdNotFound(config) {
     return {
-        command: '',
+        command: 'invalid_command',
         os: config.platform,
         version: config.version,
         exitCode: 0,
-        exitState: ['command_not_found'],
+        exitState: 'command_not_found',
         cliRunDuration: 0,
         commandRunDuration: 0,
         lifecycleHookCompletion: {
@@ -53,30 +115,81 @@ function reportCmdNotFound(config) {
             postrun: false,
             command_not_found: true,
         },
+        isVersionOrHelp: false,
     };
 }
 exports.reportCmdNotFound = reportCmdNotFound;
-async function sendTelemetry(currentTelemetry) {
+async function sendTelemetry(currentTelemetry, rollbarCb) {
     // send telemetry to honeycomb and rollbar
-    let telemetry = currentTelemetry;
+    const telemetry = currentTelemetry;
     if (telemetry instanceof Error) {
-        telemetry = { error_message: telemetry.message, error_stack: telemetry.stack };
-        telemetry.cliRunDuration = currentTelemetry.cliRunDuration;
-        await sendToRollbar(telemetry);
+        await Promise.all([
+            sendToRollbar(telemetry, rollbarCb),
+            sendToHoneycomb(telemetry),
+        ]);
+    }
+    else {
+        await sendToHoneycomb(telemetry);
     }
-    // add sendToHoneycomb function here
 }
 exports.sendTelemetry = sendTelemetry;
-async function sendToRollbar(data) {
+async function sendToHoneycomb(data) {
+    try {
+        const tracer = api_1.default.trace.getTracer('heroku-cli', version);
+        const span = tracer.startSpan('node_app_execution');
+        if (data instanceof Error) {
+            span.recordException(data);
+            span.setStatus({
+                code: api_1.SpanStatusCode.ERROR,
+                message: data.message,
+            });
+        }
+        else {
+            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);
+        }
+        span.end();
+        exports.processor.forceFlush();
+    }
+    catch (_a) {
+        debug('could not send telemetry');
+    }
+}
+exports.sendToHoneycomb = sendToHoneycomb;
+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 };
     try {
         // send data to rollbar
-        rollbar.error('Failed to complete execution', data, () => {
-            process.exit(1);
-        });
+        rollbar.error('Failed to complete execution', rollbarError, promiseResolve);
     }
     catch (_a) {
         debug('Could not send error report');
-        process.exit(1);
+        return Promise.reject();
     }
+    return rollbarPromise;
 }
 exports.sendToRollbar = sendToRollbar;

package/lib/hooks/init/performance_analytics.d.ts

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

package/lib/hooks/init/performance_analytics.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const telemetry = require("../../global_telemetry");
+const performance_analytics = async function (options) {
+    global.cliTelemetry = telemetry.setupTelemetry(this.config, options);
+};
+exports.default = performance_analytics;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "8.2.0",
+  "version": "8.3.0",
   "commands": {
     "console": {
       "id": "console",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "heroku",
   "description": "CLI to interact with Heroku",
-  "version": "8.2.0",
+  "version": "8.3.0",
   "author": "Jeff Dickey @jdxcode",
   "bin": "./bin/run",
   "bugs": "https://github.com/heroku/cli/issues",
@@ -33,6 +33,13 @@
     "@oclif/plugin-version": "^1.2.1",
     "@oclif/plugin-warn-if-update-available": "2.0.29",
     "@oclif/plugin-which": "2.2.8",
+    "@opentelemetry/api": "^1.4.1",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.41.1",
+    "@opentelemetry/instrumentation": "^0.41.1",
+    "@opentelemetry/resources": "^1.15.1",
+    "@opentelemetry/sdk-trace-base": "^1.15.1",
+    "@opentelemetry/sdk-trace-node": "^1.15.1",
+    "@opentelemetry/semantic-conventions": "^1.15.1",
     "ansi-escapes": "3.2.0",
     "async-file": "^2.0.2",
     "chalk": "^2.4.2",
@@ -254,7 +261,8 @@
     "hooks": {
       "init": [
         "./lib/hooks/init/version",
-        "./lib/hooks/init/terms-of-service"
+        "./lib/hooks/init/terms-of-service",
+        "./lib/hooks/init/performance_analytics"
       ],
       "prerun": [
         "./lib/hooks/prerun/analytics"
@@ -324,5 +332,5 @@
     "version": "oclif readme --multi && git add README.md ../../docs"
   },
   "types": "lib/index.d.ts",
-  "gitHead": "1875102f332f215ad9788b5fc117b4a2bd6bbd8c"
+  "gitHead": "16f4f8e933025276b5fc703316c3221149c29eb6"
 }