@datadog/datadog-ci 0.17.6-alpha → 0.17.9

package/dist/commands/synthetics/tunnel.d.ts

@@ -0,0 +1,43 @@
+import { ProxyConfiguration } from '../../helpers/utils';
+import { MainReporter } from './interfaces';
+export interface TunnelInfo {
+    host: string;
+    id: string;
+    privateKey: string;
+}
+export declare class Tunnel {
+    private url;
+    private testIDs;
+    private connected;
+    private forwardedSockets;
+    private FORWARDING_TIMEOUT;
+    private log;
+    private logError;
+    private logWarning;
+    private multiplexer?;
+    private privateKey;
+    private publicKey;
+    private sshConfig;
+    private ws;
+    constructor(url: string, testIDs: string[], proxy: ProxyConfiguration, reporter: MainReporter);
+    /**
+     * keepAlive will return a promise that tracks the state of the tunnel (and reject in case of error)
+     */
+    keepAlive(): Promise<void>;
+    /**
+     * start the tunnel:
+     *   - get the pre-signed URL to connect to the tunnel service
+     *   - Set up SSH
+     *   - establish a WebSocket connection to the tunnel service
+     */
+    start(): Promise<TunnelInfo>;
+    /**
+     * stop the tunnel
+     */
+    stop(): Promise<void>;
+    private authenticateSSHConnection;
+    private forwardProxiedPacketsFromSSH;
+    private forwardWebSocketToSSH;
+    private getConnectionInfo;
+    private processSSHStream;
+}

package/dist/commands/synthetics/utils.d.ts

@@ -0,0 +1,27 @@
+import { APIHelper, ConfigOverride, ExecutionRule, InternalTest, MainReporter, PollResult, Reporter, Result, Suite, Summary, TestPayload, Trigger, TriggerConfig, TriggerResponse, TriggerResult } from './interfaces';
+import { Tunnel } from './tunnel';
+export declare const handleConfig: (test: InternalTest, publicId: string, reporter: MainReporter, config?: ConfigOverride | undefined) => TestPayload;
+export declare const getExecutionRule: (test: InternalTest, configOverride?: ConfigOverride | undefined) => ExecutionRule;
+export declare const getStrictestExecutionRule: (configRule: ExecutionRule, testRule?: ExecutionRule | undefined) => ExecutionRule;
+export declare const isCriticalError: (result: Result) => boolean;
+export declare const hasResultPassed: (result: Result, failOnCriticalErrors: boolean, failOnTimeout: boolean) => boolean;
+export declare const hasTestSucceeded: (results: PollResult[], failOnCriticalErrors: boolean, failOnTimeout: boolean) => boolean;
+export declare const getSuites: (GLOB: string, reporter: MainReporter) => Promise<Suite[]>;
+export declare const wait: (duration: number) => Promise<unknown>;
+export declare const waitForResults: (api: APIHelper, triggerResponses: TriggerResponse[], defaultTimeout: number, triggerConfigs: TriggerConfig[], tunnel?: Tunnel | undefined, failOnCriticalErrors?: boolean | undefined) => Promise<{
+    [key: string]: PollResult[];
+}>;
+export declare const createTriggerResultMap: (triggerResponses: TriggerResponse[], defaultTimeout: number, triggerConfigs: TriggerConfig[]) => Map<string, TriggerResult>;
+export declare const createSummary: () => Summary;
+export declare const getResultDuration: (result: Result) => number;
+export declare const getReporter: (reporters: Reporter[]) => MainReporter;
+export declare const getTestsToTrigger: (api: APIHelper, triggerConfigs: TriggerConfig[], reporter: MainReporter) => Promise<{
+    tests: InternalTest[];
+    overriddenTestsToTrigger: TestPayload[];
+    summary: Summary;
+}>;
+export declare const runTests: (api: APIHelper, testsToTrigger: TestPayload[]) => Promise<Trigger>;
+export declare const retry: <T, E extends Error>(func: () => Promise<T>, shouldRetryAfterWait: (retries: number, error: E) => number | undefined) => Promise<T>;
+export declare const removeUndefinedValues: <T extends {
+    [key: string]: any;
+}>(object: T) => T;

package/dist/commands/synthetics/utils.js

@@ -31,7 +31,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retry = exports.runTests = exports.getTestsToTrigger = exports.getReporter = exports.getResultDuration = exports.createTriggerResultMap = exports.waitForResults = exports.wait = exports.getSuites = exports.hasTestSucceeded = exports.hasResultPassed = exports.isCriticalError = exports.getStrictestExecutionRule = exports.getExecutionRule = exports.handleConfig = void 0;
+exports.removeUndefinedValues = exports.retry = exports.runTests = exports.getTestsToTrigger = exports.getReporter = exports.getResultDuration = exports.createSummary = exports.createTriggerResultMap = exports.waitForResults = exports.wait = exports.getSuites = exports.hasTestSucceeded = exports.hasResultPassed = exports.isCriticalError = exports.getStrictestExecutionRule = exports.getExecutionRule = exports.handleConfig = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const url_1 = require("url");
@@ -284,12 +284,21 @@ const createFailingResult = (errorMessage, resultId, deviceId, dcId, tunnel) =>
     resultID: resultId,
     timestamp: 0,
 });
+const createSummary = () => ({
+    criticalErrors: 0,
+    failed: 0,
+    passed: 0,
+    skipped: 0,
+    testsNotFound: new Set(),
+    timedOut: 0,
+});
+exports.createSummary = createSummary;
 const getResultDuration = (result) => {
     if ('duration' in result) {
-        return result.duration;
+        return Math.round(result.duration);
     }
     if ('timings' in result) {
-        return result.timings.total;
+        return Math.round(result.timings.total);
     }
     return 0;
 };
@@ -356,7 +365,7 @@ exports.getReporter = getReporter;
 const getTestsToTrigger = (api, triggerConfigs, reporter) => __awaiter(void 0, void 0, void 0, function* () {
     const overriddenTestsToTrigger = [];
     const errorMessages = [];
-    const summary = { criticalErrors: 0, failed: 0, notFound: 0, passed: 0, skipped: 0, timedOut: 0 };
+    const summary = exports.createSummary();
     const tests = yield Promise.all(triggerConfigs.map(({ config, id, suite }) => __awaiter(void 0, void 0, void 0, function* () {
         let test;
         id = PUBLIC_ID_REGEX.test(id) ? id : id.substr(id.lastIndexOf('/') + 1);
@@ -367,7 +376,7 @@ const getTestsToTrigger = (api, triggerConfigs, reporter) => __awaiter(void 0, v
             if (api_1.is5xxError(e)) {
                 throw e;
             }
-            summary.notFound++;
+            summary.testsNotFound.add(id);
             const errorMessage = api_1.formatBackendErrors(e);
             errorMessages.push(`[${chalk_1.default.bold.dim(id)}] ${chalk_1.default.yellow.bold('Test not found')}: ${errorMessage}\n`);
             return;
@@ -426,3 +435,13 @@ const retry = (func, shouldRetryAfterWait) => __awaiter(void 0, void 0, void 0,
     return trier();
 });
 exports.retry = retry;
+const removeUndefinedValues = (object) => {
+    const newObject = Object.assign({}, object);
+    for (const [key, value] of Object.entries(newObject)) {
+        if (value === undefined) {
+            delete newObject[key];
+        }
+    }
+    return newObject;
+};
+exports.removeUndefinedValues = removeUndefinedValues;

package/dist/commands/synthetics/websocket.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { default as WebSocketModule } from 'ws';
+import { ProxyConfiguration } from '../../helpers/utils';
+export declare class WebSocket extends EventEmitter {
+    private url;
+    private proxyOpts;
+    private firstMessage?;
+    private keepAliveWebsocket?;
+    private websocket?;
+    constructor(url: string, proxyOpts: ProxyConfiguration);
+    /**
+     * close will terminate the WebSocket connection
+     */
+    close(gracefullyClose?: boolean): Promise<void>;
+    /**
+     * connect will start a WebSocket connection
+     */
+    connect(): Promise<void>;
+    /**
+     * duplex will create a duplex stream for the WS connection
+     */
+    duplex(): import("stream").Duplex;
+    /**
+     * keepAlive will return a promise to keep track of the tunnel connection
+     */
+    keepAlive(): Promise<void>;
+    /**
+     * on allows to listen for WebSocket messages
+     */
+    on(event: 'message', listener: (data: WebSocketModule.Data) => void): this;
+    /**
+     * once allows to listen for a WebSocket message
+     */
+    once(event: 'message', listener: (data: WebSocketModule.Data) => void): this;
+    waitForFirstMessage(): Promise<WebSocketModule.Data>;
+    private establishWebsocketConnection;
+}

package/dist/commands/trace/__tests__/trace.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/trace/api.d.ts

@@ -0,0 +1,6 @@
+import type { AxiosPromise, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { Payload } from './interfaces';
+export declare const reportCustomSpan: (request: (args: AxiosRequestConfig) => AxiosPromise<AxiosResponse>) => (customSpan: Payload, provider: string) => Promise<AxiosResponse<AxiosResponse<any>>>;
+export declare const apiConstructor: (baseUrl: string, apiKey: string) => {
+    reportCustomSpan: (customSpan: Payload, provider: string) => Promise<AxiosResponse<AxiosResponse<any>>>;
+};

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

@@ -0,0 +1 @@
+export {};

package/dist/commands/trace/interfaces.d.ts

@@ -0,0 +1,23 @@
+import { AxiosPromise, AxiosResponse } from 'axios';
+export declare const CIRCLECI = "circleci";
+export declare const JENKINS = "jenkins";
+export declare const SUPPORTED_PROVIDERS: readonly ["circleci", "jenkins"];
+export declare type Provider = typeof SUPPORTED_PROVIDERS[number];
+export interface Payload {
+    command: string;
+    custom: {
+        id: string;
+        parent_id?: string;
+    };
+    data: Record<string, string>;
+    end_time: string;
+    error_message: string;
+    exit_code: number;
+    is_error: boolean;
+    name: string;
+    start_time: string;
+    tags: Partial<Record<string, string>>;
+}
+export interface APIHelper {
+    reportCustomSpan(customSpan: Payload, provider: Provider): AxiosPromise<AxiosResponse>;
+}

package/dist/commands/trace/trace.d.ts

@@ -0,0 +1,17 @@
+import { Command } from 'clipanion';
+import { Provider } from './interfaces';
+export declare class TraceCommand extends Command {
+    static usage: import("clipanion/lib/advanced").Usage;
+    private command?;
+    private config;
+    private name?;
+    private noFail?;
+    private tags?;
+    execute(): Promise<number>;
+    getCIEnvVars(): [Record<string, string>, Provider?];
+    private getApiHelper;
+    private getBaseIntakeUrl;
+    private getEnvironmentVars;
+    private reportCustomSpan;
+    private signalToNumber;
+}

package/dist/commands/trace/trace.js

@@ -18,6 +18,7 @@ const child_process_1 = require("child_process");
 const clipanion_1 = require("clipanion");
 const crypto_1 = __importDefault(require("crypto"));
 const os_1 = __importDefault(require("os"));
+const retry_1 = require("../../helpers/retry");
 const tags_1 = require("../../helpers/tags");
 const api_1 = require("./api");
 const interfaces_1 = require("./interfaces");
@@ -41,7 +42,17 @@ class TraceCommand extends clipanion_1.Command {
             const [command, ...args] = this.command;
             const id = crypto_1.default.randomBytes(5).toString('hex');
             const startTime = new Date().toISOString();
-            const childProcess = child_process_1.spawn(command, args, { env: Object.assign(Object.assign({}, process.env), { DD_CUSTOM_PARENT_ID: id }), stdio: 'inherit' });
+            const childProcess = child_process_1.spawn(command, args, {
+                env: Object.assign(Object.assign({}, process.env), { DD_CUSTOM_PARENT_ID: id }),
+                stdio: ['inherit', 'inherit', 'pipe'],
+            });
+            const chunks = [];
+            childProcess.stderr.pipe(this.context.stderr);
+            const stderrCatcher = new Promise((resolve, reject) => {
+                childProcess.stderr.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+                childProcess.stderr.on('error', (err) => reject(err));
+                childProcess.stderr.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+            });
             const [status, signal] = yield new Promise((resolve, reject) => {
                 childProcess.on('error', (error) => {
                     reject(error);
@@ -50,15 +61,15 @@ class TraceCommand extends clipanion_1.Command {
                     resolve([exitStatus, exitSignal]);
                 });
             });
+            const stderr = yield stderrCatcher;
             const endTime = new Date().toISOString();
             const exitCode = (_a = status !== null && status !== void 0 ? status : this.signalToNumber(signal)) !== null && _a !== void 0 ? _a : BAD_COMMAND_EXIT_CODE;
             const [ciEnvVars, provider] = this.getCIEnvVars();
             if (provider) {
-                const api = this.getApiHelper();
                 const commandStr = this.command.join(' ');
                 const envVarTags = this.config.envVarTags ? tags_1.parseTags(this.config.envVarTags.split(',')) : {};
                 const cliTags = this.tags ? tags_1.parseTags(this.tags) : {};
-                yield api.reportCustomSpan({
+                yield this.reportCustomSpan({
                     command: commandStr,
                     custom: {
                         id,
@@ -66,6 +77,8 @@ class TraceCommand extends clipanion_1.Command {
                     },
                     data: ciEnvVars,
                     end_time: endTime,
+                    error_message: stderr,
+                    exit_code: exitCode,
                     is_error: exitCode !== 0,
                     name: (_b = this.name) !== null && _b !== void 0 ? _b : commandStr,
                     start_time: startTime,
@@ -151,6 +164,22 @@ class TraceCommand extends clipanion_1.Command {
     getEnvironmentVars(keys) {
         return keys.filter((key) => key in process.env).reduce((accum, key) => (Object.assign(Object.assign({}, accum), { [key]: process.env[key] })), {});
     }
+    reportCustomSpan(payload, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = this.getApiHelper();
+            try {
+                yield retry_1.retryRequest(() => api.reportCustomSpan(payload, provider), {
+                    onRetry: (e, attempt) => {
+                        this.context.stderr.write(chalk_1.default.yellow(`[attempt ${attempt}] Could not report custom span. Retrying...: ${e.message}\n`));
+                    },
+                    retries: 5,
+                });
+            }
+            catch (error) {
+                this.context.stderr.write(chalk_1.default.red(`Failed to report custom span: ${error.message}\n`));
+            }
+        });
+    }
     signalToNumber(signal) {
         if (!signal) {
             return undefined;

package/dist/helpers/__tests__/ci.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/__tests__/ci.test.js

@@ -75,6 +75,7 @@ describe('getCIMetadata', () => {
             GITHUB_REF: branch,
             GITHUB_REPOSITORY: 'DataDog/datadog-ci',
             GITHUB_RUN_ID: '42',
+            GITHUB_SERVER_URL: 'https://github.com',
             GITHUB_SHA: commit,
         };
         const expectedPipelineURL = 'https://github.com/DataDog/datadog-ci/actions/runs/42';
@@ -89,6 +90,28 @@ describe('getCIMetadata', () => {
             },
         });
     });
+    test('github actions with run attempt is recognized', () => {
+        process.env = {
+            GITHUB_ACTIONS: 'true',
+            GITHUB_REF: branch,
+            GITHUB_REPOSITORY: 'DataDog/datadog-ci',
+            GITHUB_RUN_ATTEMPT: '2',
+            GITHUB_RUN_ID: '42',
+            GITHUB_SERVER_URL: 'https://github.com',
+            GITHUB_SHA: commit,
+        };
+        const expectedPipelineURL = 'https://github.com/DataDog/datadog-ci/actions/runs/42/attempts/2';
+        expect(ci_1.getCIMetadata()).toEqual({
+            ci: {
+                pipeline: { url: expectedPipelineURL },
+                provider: { name: ci_1.CI_ENGINES.GITHUB },
+            },
+            git: {
+                branch,
+                commitSha: commit,
+            },
+        });
+    });
     test('jenkins is recognized', () => {
         process.env = {
             BUILD_URL: pipelineURL,

package/dist/helpers/__tests__/git.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/__tests__/retry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/__tests__/retry.test.js

@@ -0,0 +1,98 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const retry_1 = require("../retry");
+describe('retry', () => {
+    const retryCallback = jest.fn();
+    const createResultWithErrors = (errors) => {
+        let i = -1;
+        return () => {
+            i = i + 1;
+            if (errors[i] === undefined) {
+                return Promise.resolve({
+                    config: {},
+                    data: {},
+                    headers: undefined,
+                    status: 200,
+                    statusText: '',
+                });
+            }
+            return Promise.reject(errors[i]);
+        };
+    };
+    beforeEach(() => {
+        jest.restoreAllMocks();
+    });
+    const buildHttpError = (statusCode) => ({
+        response: {
+            status: statusCode,
+        },
+    });
+    test('should retry retriable failed requests', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield retry_1.retryRequest(createResultWithErrors([buildHttpError(500), undefined]), {
+            maxTimeout: 50,
+            minTimeout: 10,
+            onRetry: retryCallback,
+            retries: 5,
+        });
+        expect(retryCallback).toBeCalledTimes(1);
+    }));
+    test('should retry non-http errors', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield retry_1.retryRequest(createResultWithErrors([{ message: 'Connection timeout' }, undefined]), {
+            maxTimeout: 50,
+            minTimeout: 10,
+            onRetry: retryCallback,
+            retries: 5,
+        });
+        expect(retryCallback).toBeCalledTimes(1);
+    }));
+    test('should not retry some clients failures', () => __awaiter(void 0, void 0, void 0, function* () {
+        let threwError = false;
+        try {
+            yield retry_1.retryRequest(createResultWithErrors([buildHttpError(413)]), {
+                maxTimeout: 50,
+                minTimeout: 10,
+                onRetry: retryCallback,
+                retries: 5,
+            });
+        }
+        catch (error) {
+            threwError = true;
+        }
+        expect(threwError).toBeTruthy();
+        expect(retryCallback).toBeCalledTimes(0);
+    }));
+    test('should retry only a given amount of times', () => __awaiter(void 0, void 0, void 0, function* () {
+        let threwError = false;
+        try {
+            yield retry_1.retryRequest(createResultWithErrors([buildHttpError(500), buildHttpError(500), buildHttpError(500), buildHttpError(500)]), {
+                maxTimeout: 20,
+                minTimeout: 10,
+                onRetry: retryCallback,
+                retries: 3,
+            });
+        }
+        catch (error) {
+            threwError = true;
+        }
+        expect(threwError).toBeTruthy();
+        expect(retryCallback).toBeCalledTimes(3);
+    }));
+    test('should not retry if the call was successful', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield retry_1.retryRequest(createResultWithErrors([undefined]), {
+            maxTimeout: 50,
+            minTimeout: 10,
+            onRetry: retryCallback,
+            retries: 5,
+        });
+        expect(retryCallback).toBeCalledTimes(0);
+    }));
+});

package/dist/helpers/__tests__/tags.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/__tests__/upload.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/__tests__/user-provided-git.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/__tests__/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/apikey.d.ts

@@ -0,0 +1,14 @@
+import { AxiosError } from 'axios';
+import { BufferedMetricsLogger } from 'datadog-metrics';
+/** ApiKeyValidator is an helper interface to interpret Datadog error responses and possibly check the
+ * validity of the api key.
+ */
+export interface ApiKeyValidator {
+    verifyApiKey(error: AxiosError): Promise<void>;
+}
+export interface ApiKeyValidatorParams {
+    apiKey: string | undefined;
+    datadogSite: string;
+    metricsLogger?: BufferedMetricsLogger;
+}
+export declare const newApiKeyValidator: (params: ApiKeyValidatorParams) => ApiKeyValidator;

package/dist/helpers/ci.d.ts

@@ -0,0 +1,15 @@
+import { Metadata, SpanTags } from './interfaces';
+export declare const CI_ENGINES: {
+    APPVEYOR: string;
+    AZURE: string;
+    BITBUCKET: string;
+    BITRISE: string;
+    BUILDKITE: string;
+    CIRCLECI: string;
+    GITHUB: string;
+    GITLAB: string;
+    JENKINS: string;
+    TRAVIS: string;
+};
+export declare const getCISpanTags: () => SpanTags | undefined;
+export declare const getCIMetadata: () => Metadata | undefined;

package/dist/helpers/ci.js

@@ -125,13 +125,17 @@ const getCISpanTags = () => {
         };
     }
     if (env.GITHUB_ACTIONS || env.GITHUB_ACTION) {
-        const { GITHUB_RUN_ID, GITHUB_WORKFLOW, GITHUB_RUN_NUMBER, GITHUB_WORKSPACE, GITHUB_HEAD_REF, GITHUB_REF, GITHUB_SHA, GITHUB_REPOSITORY, } = env;
-        const repositoryUrl = `https://github.com/${GITHUB_REPOSITORY}.git`;
-        const pipelineURL = `https://github.com/${GITHUB_REPOSITORY}/commit/${GITHUB_SHA}/checks`;
+        const { GITHUB_RUN_ID, GITHUB_WORKFLOW, GITHUB_RUN_NUMBER, GITHUB_WORKSPACE, GITHUB_HEAD_REF, GITHUB_REF, GITHUB_SHA, GITHUB_REPOSITORY, GITHUB_SERVER_URL, } = env;
+        const repositoryUrl = `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}.git`;
+        let pipelineURL = `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}`;
+        // Some older versions of enterprise might not have this yet.
+        if (env.GITHUB_RUN_ATTEMPT) {
+            pipelineURL += `/attempts/${env.GITHUB_RUN_ATTEMPT}`;
+        }
         const ref = GITHUB_HEAD_REF || GITHUB_REF || '';
         const refKey = ref.includes('tags') ? tags_1.GIT_TAG : tags_1.GIT_BRANCH;
         tags = {
-            [tags_1.CI_JOB_URL]: pipelineURL,
+            [tags_1.CI_JOB_URL]: `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/commit/${GITHUB_SHA}/checks`,
             [tags_1.CI_PIPELINE_ID]: GITHUB_RUN_ID,
             [tags_1.CI_PIPELINE_NAME]: GITHUB_WORKFLOW,
             [tags_1.CI_PIPELINE_NUMBER]: GITHUB_RUN_NUMBER,
@@ -339,8 +343,11 @@ const getCIMetadata = () => {
         };
     }
     if (env.GITHUB_ACTIONS) {
-        const { GITHUB_REF, GITHUB_SHA, GITHUB_REPOSITORY, GITHUB_RUN_ID } = env;
-        const pipelineURL = `https://github.com/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}`;
+        const { GITHUB_REF, GITHUB_SHA, GITHUB_REPOSITORY, GITHUB_RUN_ID, GITHUB_SERVER_URL } = env;
+        let pipelineURL = `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}`;
+        if (env.GITHUB_RUN_ATTEMPT) {
+            pipelineURL += `/attempts/${env.GITHUB_RUN_ATTEMPT}`;
+        }
         return {
             ci: {
                 pipeline: {

package/dist/helpers/errors.d.ts

@@ -0,0 +1,2 @@
+export declare class InvalidConfigurationError extends Error {
+}

package/dist/helpers/formatting.d.ts

@@ -0,0 +1,5 @@
+export declare const ICONS: {
+    FAILED: string;
+    SUCCESS: string;
+    WARNING: string;
+};

package/dist/helpers/git.d.ts

@@ -0,0 +1,2 @@
+import type { SpanTags } from './interfaces';
+export declare const getGitMetadata: () => Promise<SpanTags>;

package/dist/helpers/interfaces.d.ts

@@ -0,0 +1,19 @@
+import { AxiosPromise, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { CI_JOB_NAME, CI_JOB_URL, CI_PIPELINE_ID, CI_PIPELINE_NAME, CI_PIPELINE_NUMBER, CI_PIPELINE_URL, CI_PROVIDER_NAME, CI_STAGE_NAME, CI_WORKSPACE_PATH, GIT_BRANCH, GIT_COMMIT_AUTHOR_DATE, GIT_COMMIT_AUTHOR_EMAIL, GIT_COMMIT_AUTHOR_NAME, GIT_COMMIT_COMMITTER_DATE, GIT_COMMIT_COMMITTER_EMAIL, GIT_COMMIT_COMMITTER_NAME, GIT_COMMIT_MESSAGE, GIT_REPOSITORY_URL, GIT_SHA, GIT_TAG } from './tags';
+export interface Metadata {
+    ci: {
+        pipeline: {
+            url?: string;
+        };
+        provider: {
+            name: string;
+        };
+    };
+    git: {
+        branch?: string;
+        commitSha?: string;
+    };
+}
+export declare type SpanTag = typeof CI_JOB_NAME | typeof CI_JOB_URL | typeof CI_PIPELINE_ID | typeof CI_PIPELINE_NAME | typeof CI_PIPELINE_NUMBER | typeof CI_PIPELINE_URL | typeof CI_PROVIDER_NAME | typeof CI_STAGE_NAME | typeof CI_WORKSPACE_PATH | typeof GIT_BRANCH | typeof GIT_REPOSITORY_URL | typeof GIT_SHA | typeof GIT_TAG | typeof GIT_COMMIT_AUTHOR_EMAIL | typeof GIT_COMMIT_AUTHOR_NAME | typeof GIT_COMMIT_AUTHOR_DATE | typeof GIT_COMMIT_MESSAGE | typeof GIT_COMMIT_COMMITTER_DATE | typeof GIT_COMMIT_COMMITTER_EMAIL | typeof GIT_COMMIT_COMMITTER_NAME;
+export declare type SpanTags = Partial<Record<SpanTag, string>>;
+export declare type RequestBuilder = (args: AxiosRequestConfig) => AxiosPromise<AxiosResponse>;

package/dist/helpers/metrics.d.ts

@@ -0,0 +1,11 @@
+import metrics from 'datadog-metrics';
+export interface MetricsLogger {
+    logger: metrics.BufferedMetricsLogger;
+    flush(): Promise<void>;
+}
+export interface MetricsLoggerOptions {
+    datadogSite?: string;
+    defaultTags?: string[];
+    prefix: string;
+}
+export declare const getMetricsLogger: (opts: MetricsLoggerOptions) => MetricsLogger;

package/dist/helpers/retry.d.ts

@@ -0,0 +1,2 @@
+import retry from 'async-retry';
+export declare const retryRequest: (requestPerformer: () => Promise<any>, retryOpts: retry.Options) => Promise<void>;

package/dist/helpers/retry.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryRequest = void 0;
+const async_retry_1 = __importDefault(require("async-retry"));
+const errorCodesNoRetry = [400, 403, 413];
+const retryRequest = (requestPerformer, retryOpts) => __awaiter(void 0, void 0, void 0, function* () {
+    // Request function, passed to async-retry
+    const doRequest = (bail) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield requestPerformer();
+        }
+        catch (error) {
+            if (error.response && errorCodesNoRetry.includes(error.response.status)) {
+                // If it's an axios error with a status code that is excluded from retries, we bail to avoid retrying
+                bail(error);
+                return;
+            }
+            // Other cases are retried: other axios HTTP errors as well as
+            // non-axios errors such as DNS resolution errors and connection timeouts
+            throw error;
+        }
+    });
+    // Do the actual call
+    return async_retry_1.default(doRequest, retryOpts);
+});
+exports.retryRequest = retryRequest;