heroku 9.3.2 → 10.0.0-alpha.0

package/lib/commands/telemetry/info.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const util_1 = require("../../lib/telemetry/util");
+class Info extends command_1.Command {
+    async run() {
+        const { args } = await this.parse(Info);
+        const { telemetry_drain_id } = args;
+        const { body: telemetryDrain } = await this.heroku.get(`/telemetry-drains/${telemetry_drain_id}`, {
+            headers: {
+                Accept: 'application/vnd.heroku+json; version=3.sdk',
+            },
+        });
+        (0, util_1.displayTelemetryDrain)(telemetryDrain);
+    }
+}
+exports.default = Info;
+Info.topic = 'telemetry';
+Info.description = 'show a telemetry drain\'s info';
+Info.args = {
+    telemetry_drain_id: core_1.Args.string({ required: true, description: 'ID of the drain to show info for' }),
+};
+Info.example = '$ heroku telemetry:info 022e2e2e-2e2e-2e2e-2e2e-2e2e2e2e2e2e';

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+import { TelemetryDrain } from '../../lib/types/telemetry';
+export default class Remove extends Command {
+    static topic: string;
+    static description: string;
+    static args: {
+        telemetry_drain_id: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+    protected removeDrain(telemetry_drain_id: string): Promise<TelemetryDrain>;
+}

package/lib/commands/telemetry/remove.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+class Remove extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(Remove);
+        const { app, space } = flags;
+        const { telemetry_drain_id } = args;
+        if (!(app || space || telemetry_drain_id)) {
+            core_1.ux.error((0, tsheredoc_1.default)(`
+        Requires either --app or --space or a TELEMETRY_DRAIN_ID to be provided.
+        See more help with --help
+      `));
+        }
+        if (telemetry_drain_id) {
+            const telemetryDrain = await this.removeDrain(telemetry_drain_id);
+            core_1.ux.action.start(`Removing telemetry drain ${telemetry_drain_id}, which was configured for ${telemetryDrain.owner.type} ${telemetryDrain.owner.name}`);
+        }
+        else if (app) {
+            core_1.ux.action.start(`Removing all telemetry drains from app ${app}`);
+            const { body: telemetryDrains } = await this.heroku.get(`/apps/${app}/telemetry-drains`, {
+                headers: {
+                    Accept: 'application/vnd.heroku+json; version=3.sdk',
+                },
+            });
+            for (const telemetryDrain of telemetryDrains) {
+                await this.removeDrain(telemetryDrain.id);
+            }
+        }
+        else if (space) {
+            core_1.ux.action.start(`Removing all telemetry drains from space ${space}`);
+            const { body: telemetryDrains } = await this.heroku.get(`/spaces/${space}/telemetry-drains`, {
+                headers: {
+                    Accept: 'application/vnd.heroku+json; version=3.sdk',
+                },
+            });
+            for (const telemetryDrain of telemetryDrains) {
+                await this.removeDrain(telemetryDrain.id);
+            }
+        }
+        core_1.ux.action.stop();
+    }
+    async removeDrain(telemetry_drain_id) {
+        const { body: telemetryDrain } = await this.heroku.delete(`/telemetry-drains/${telemetry_drain_id}`, {
+            headers: {
+                Accept: 'application/vnd.heroku+json; version=3.sdk',
+            },
+        });
+        return telemetryDrain;
+    }
+}
+exports.default = Remove;
+Remove.topic = 'telemetry';
+Remove.description = 'remove a telemetry drain';
+Remove.args = {
+    telemetry_drain_id: core_1.Args.string({ description: 'ID of the drain to remove' }),
+};
+Remove.flags = {
+    app: command_1.flags.app({ description: 'name of the app to remove all drains from' }),
+    space: command_1.flags.string({ char: 's', description: 'name of the space to remove all drains from' }),
+};

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

@@ -0,0 +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/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+        headers: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        signals: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        endpoint: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        transport: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static example: string;
+    run(): Promise<void>;
+}

package/lib/commands/telemetry/update.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const util_1 = require("../../lib/telemetry/util");
+class Update extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(Update);
+        const { telemetry_drain_id, headers } = args;
+        const { signals, endpoint, transport } = flags;
+        if (!(headers || signals || endpoint || transport)) {
+            core_1.ux.error((0, tsheredoc_1.default)(`
+        Requires either --signals, --endpoint, --transport or HEADERS to be provided.
+        See more help with --help
+      `));
+        }
+        const drainConfig = {};
+        if (signals) {
+            drainConfig.signals = (0, util_1.validateAndFormatSignals)(signals);
+        }
+        if (headers || endpoint || transport) {
+            const exporter = {};
+            if (headers) {
+                exporter.headers = JSON.parse(headers);
+            }
+            if (endpoint) {
+                exporter.endpoint = endpoint;
+            }
+            if (transport) {
+                exporter.type = `otlp${transport}`;
+            }
+            drainConfig.exporter = exporter;
+        }
+        core_1.ux.action.start(`Updating telemetry drain ${telemetry_drain_id}`);
+        const { body: telemetryDrain } = await this.heroku.patch(`/telemetry-drains/${telemetry_drain_id}`, {
+            headers: {
+                Accept: 'application/vnd.heroku+json; version=3.sdk',
+            },
+            body: drainConfig,
+        });
+        core_1.ux.action.stop();
+        (0, util_1.displayTelemetryDrain)(telemetryDrain);
+    }
+}
+exports.default = Update;
+Update.topic = 'telemetry';
+Update.description = 'updates a telemetry drain with provided attributes (attributes not provided remain unchanged)';
+Update.args = {
+    telemetry_drain_id: core_1.Args.string({ required: true, description: 'ID of the drain to update' }),
+    headers: core_1.Args.string({ description: 'custom headers to configure the drain in json format' }),
+};
+Update.flags = {
+    signals: command_1.flags.string({ description: 'comma-delimited list of signals to collect (traces, metrics, logs). Use "all" to collect all signals.' }),
+    endpoint: command_1.flags.string({ description: 'drain url' }),
+    transport: command_1.flags.string({ options: ['http', 'grpc'], description: 'transport protocol for the drain' }),
+};
+Update.example = (0, tsheredoc_1.default)(`
+    $ heroku telemetry:update acde070d-8c4c-4f0d-9d8a-162843c10333 --signals logs,metrics --endpoint https://my-new-endpoint.com
+  `);

package/lib/file.js

@@ -9,7 +9,6 @@ function exists(f) {
 }
 exports.exists = exists;
 async function stat(file) {
-    // debug('stat', file)
     return deps_1.default.fs.stat(file);
 }
 exports.stat = stat;
@@ -42,7 +41,6 @@ async function removeEmptyDirs(dir) {
         throw error;
     }
     const dirs = files.filter(f => f.stat.isDirectory()).map(f => f.path);
-    // eslint-disable-next-line unicorn/no-array-callback-reference
     for (const p of dirs.map(removeEmptyDirs))
         await p;
     files = await ls(dir);

package/lib/lib/apps/generation.d.ts

@@ -0,0 +1,4 @@
+import { APIClient } from '@heroku-cli/command';
+import { App } from '../types/fir';
+export declare function isFirApp(appOrName: App | string, herokuApi?: APIClient): Promise<boolean>;
+export declare function isCedarApp(appOrName: App | string, herokuApi?: APIClient): Promise<boolean>;

package/lib/lib/apps/generation.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCedarApp = exports.isFirApp = void 0;
+async function getApp(appOrName, herokuApi) {
+    if (typeof appOrName === 'string') {
+        if (herokuApi === undefined)
+            throw new Error('herokuApi parameter is required when passing an app name');
+        const { body: app } = await herokuApi.get(`/apps/${appOrName}`, {
+            headers: { Accept: 'application/vnd.heroku+json; version=3.sdk' },
+        });
+        return app;
+    }
+    return appOrName;
+}
+async function isFirApp(appOrName, herokuApi) {
+    const app = await getApp(appOrName, herokuApi);
+    return app.generation === 'fir';
+}
+exports.isFirApp = isFirApp;
+async function isCedarApp(appOrName, herokuApi) {
+    const app = await getApp(appOrName, herokuApi);
+    return app.generation === 'cedar';
+}
+exports.isCedarApp = isCedarApp;

package/lib/lib/run/colorize.js

@@ -267,7 +267,7 @@ function colorizePG(body) {
     return body;
 }
 function colorize(line) {
-    if (process.env.HEROKU_LOGS_COLOR === '0')
+    if (process.env.HEROKU_LOGS_COLOR === '0' || process.env.HEROKU_COLOR === '0')
         return line;
     const parsed = line.match(lineRegex);
     if (!parsed)

package/lib/lib/run/log-displayer.d.ts

@@ -3,8 +3,9 @@ interface LogDisplayerOptions {
     app: string;
     dyno?: string;
     lines?: number;
-    tail: boolean;
     source?: string;
+    tail: boolean;
+    type?: string;
 }
-declare function logDisplayer(heroku: APIClient, options: LogDisplayerOptions): Promise<unknown>;
+declare function logDisplayer(heroku: APIClient, options: LogDisplayerOptions): Promise<void>;
 export default logDisplayer;

package/lib/lib/run/log-displayer.js

@@ -1,26 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
-const http_call_1 = require("http-call");
-const url_1 = require("url");
 const colorize_1 = require("./colorize");
-const line_transform_1 = require("./line-transform");
+const generation_1 = require("../apps/generation");
 const EventSource = require('@heroku/eventsource');
-async function readLogsV1(logplexURL) {
-    const { response } = await http_call_1.default.stream(logplexURL);
+function readLogs(logplexURL, isTail, recreateSessionTimeout) {
     return new Promise(function (resolve, reject) {
-        response.setEncoding('utf8');
-        line_transform_1.default.setEncoding('utf8');
-        response.pipe(line_transform_1.default);
-        line_transform_1.default.on('data', line => core_1.ux.log((0, colorize_1.default)(line)));
-        response.on('end', resolve);
-        response.on('error', reject);
-    });
-}
-function readLogsV2(logplexURL) {
-    return new Promise(function (resolve, reject) {
-        const u = new url_1.URL(logplexURL);
-        const isTail = u.searchParams.get('tail') === 'true';
         const userAgent = process.env.HEROKU_DEBUG_USER_AGENT || 'heroku-run';
         const proxy = process.env.https_proxy || process.env.HTTPS_PROXY;
         const es = new EventSource(logplexURL, {
@@ -33,8 +18,8 @@ function readLogsV2(logplexURL) {
             if (err && (err.status || err.message)) {
                 const msg = (isTail && (err.status === 404 || err.status === 403)) ?
                     'Log stream timed out. Please try again.' :
-                    `Logs eventsource failed with: ${err.status} ${err.message}`;
-                reject(msg);
+                    `Logs eventsource failed with: ${err.status}${err.message ? ` ${err.message}` : ''}`;
+                reject(new Error(msg));
                 es.close();
             }
             if (!isTail) {
@@ -48,15 +33,14 @@ function readLogsV2(logplexURL) {
                 core_1.ux.log((0, colorize_1.default)(line));
             });
         });
+        if (isTail && recreateSessionTimeout) {
+            setTimeout(() => {
+                reject(new Error('Fir log stream timeout'));
+                es.close();
+            }, recreateSessionTimeout);
+        }
     });
 }
-function readLogs(logplexURL) {
-    const u = new url_1.URL(logplexURL);
-    if (u.searchParams.has('srv')) {
-        return readLogsV1(logplexURL);
-    }
-    return readLogsV2(logplexURL);
-}
 async function logDisplayer(heroku, options) {
     process.stdout.on('error', err => {
         if (err.code === 'EPIPE') {
@@ -66,14 +50,38 @@ async function logDisplayer(heroku, options) {
             core_1.ux.error(err.stack, { exit: 1 });
         }
     });
-    const response = await heroku.post(`/apps/${options.app}/log-sessions`, {
-        body: {
-            tail: options.tail,
+    const firApp = await (0, generation_1.isFirApp)(options.app, heroku);
+    const isTail = firApp || options.tail;
+    const requestBodyParameters = {
+        source: options.source,
+    };
+    if (firApp)
+        Object.assign(requestBodyParameters, {
             dyno: options.dyno,
-            source: options.source,
+            type: options.type,
+        });
+    else
+        Object.assign(requestBodyParameters, {
+            dyno: options.dyno || options.type,
             lines: options.lines,
-        },
-    });
-    return readLogs(response.body.logplex_url);
+            tail: options.tail,
+        });
+    let recreateLogSession = false;
+    do {
+        const { body: logSession } = await heroku.post(`/apps/${options.app}/log-sessions`, {
+            body: requestBodyParameters,
+            headers: { Accept: 'application/vnd.heroku+json; version=3.sdk' },
+        });
+        try {
+            await readLogs(logSession.logplex_url, isTail, firApp ? Number(process.env.HEROKU_LOG_STREAM_TIMEOUT || '15') * 60 * 1000 : undefined);
+        }
+        catch (error) {
+            const { message } = error;
+            if (message === 'Fir log stream timeout')
+                recreateLogSession = true;
+            else
+                core_1.ux.error(message, { exit: 1 });
+        }
+    } while (recreateLogSession);
 }
 exports.default = logDisplayer;

package/lib/lib/spaces/spaces.d.ts

@@ -1,4 +1,6 @@
 import * as Heroku from '@heroku-cli/schema';
+import { SpaceNat } from '../types/fir';
+import { SpaceWithOutboundIps } from '../types/spaces';
 export declare function displayShieldState(space: Heroku.Space): "on" | "off";
-export declare function displayNat(nat?: Required<Heroku.SpaceNetworkAddressTranslation>): string | undefined;
-export declare function renderInfo(space: Heroku.Space, json: boolean): void;
+export declare function displayNat(nat?: Required<SpaceNat>): string | undefined;
+export declare function renderInfo(space: SpaceWithOutboundIps, json: boolean): void;

package/lib/lib/spaces/spaces.js

@@ -30,8 +30,9 @@ function renderInfo(space, json) {
             State: space.state,
             Shield: displayShieldState(space),
             'Outbound IPs': displayNat(space.outbound_ips),
+            Generation: space.generation,
             'Created at': space.created_at,
-        }, ['ID', 'Team', 'Region', 'CIDR', 'Data CIDR', 'State', 'Shield', 'Outbound IPs', 'Created at']);
+        }, ['ID', 'Team', 'Region', 'CIDR', 'Data CIDR', 'State', 'Shield', 'Outbound IPs', 'Generation', 'Created at']);
     }
 }
 exports.renderInfo = renderInfo;

package/lib/lib/telemetry/util.d.ts

@@ -0,0 +1,3 @@
+import { TelemetryDrain } from '../types/telemetry';
+export declare function validateAndFormatSignals(signalInput: string | undefined): string[];
+export declare function displayTelemetryDrain(telemetryDrain: TelemetryDrain): void;

package/lib/lib/telemetry/util.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayTelemetryDrain = exports.validateAndFormatSignals = void 0;
+const core_1 = require("@oclif/core");
+function validateAndFormatSignals(signalInput) {
+    const signalOptions = ['traces', 'metrics', 'logs'];
+    if (!signalInput || signalInput === 'all')
+        return signalOptions;
+    const signalArray = signalInput.split(',');
+    signalArray.forEach(signal => {
+        if (!signalOptions.includes(signal)) {
+            core_1.ux.error(`Invalid signal option: ${signalArray}. Run heroku telemetry:add --help to see signal options.`, { exit: 1 });
+        }
+    });
+    return signalArray;
+}
+exports.validateAndFormatSignals = validateAndFormatSignals;
+function displayTelemetryDrain(telemetryDrain) {
+    core_1.ux.styledHeader(telemetryDrain.id);
+    const drainType = telemetryDrain.owner.type.charAt(0).toUpperCase() + telemetryDrain.owner.type.slice(1);
+    core_1.ux.styledObject({
+        [drainType]: telemetryDrain.owner.name,
+        Signals: telemetryDrain.signals.join(', '),
+        Endpoint: telemetryDrain.exporter.endpoint,
+        Kind: telemetryDrain.exporter.type,
+        Headers: telemetryDrain.exporter.headers,
+    }, ['App', 'Space', 'Signals', 'Endpoint', 'Kind', 'Headers']);
+}
+exports.displayTelemetryDrain = displayTelemetryDrain;