@datadog/datadog-ci 0.17.4 → 0.17.7

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

@@ -53,7 +53,7 @@ describe('getCIMetadata', () => {
     });
     test('gitlab CI is recognized', () => {
         process.env = {
-            CI_COMMIT_BRANCH: branch,
+            CI_COMMIT_REF_NAME: branch,
             CI_COMMIT_SHA: commit,
             CI_JOB_URL: pipelineURL,
             GITLAB_CI: 'true',

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

@@ -102,7 +102,7 @@ const getCISpanTags = () => {
         tags[refKey] = ref;
     }
     if (env.GITLAB_CI) {
-        const { CI_PIPELINE_ID: GITLAB_CI_PIPELINE_ID, CI_PROJECT_PATH, CI_PIPELINE_IID, CI_PIPELINE_URL: GITLAB_CI_PIPELINE_URL, CI_PROJECT_DIR, CI_COMMIT_BRANCH, CI_COMMIT_TAG, CI_COMMIT_SHA, CI_REPOSITORY_URL, CI_JOB_URL: GITLAB_CI_JOB_URL, CI_JOB_STAGE, CI_JOB_NAME: GITLAB_CI_JOB_NAME, CI_COMMIT_MESSAGE, CI_COMMIT_TIMESTAMP, CI_COMMIT_AUTHOR, } = env;
+        const { CI_PIPELINE_ID: GITLAB_CI_PIPELINE_ID, CI_PROJECT_PATH, CI_PIPELINE_IID, CI_PIPELINE_URL: GITLAB_CI_PIPELINE_URL, CI_PROJECT_DIR, CI_COMMIT_REF_NAME, CI_COMMIT_TAG, CI_COMMIT_SHA, CI_REPOSITORY_URL, CI_JOB_URL: GITLAB_CI_JOB_URL, CI_JOB_STAGE, CI_JOB_NAME: GITLAB_CI_JOB_NAME, CI_COMMIT_MESSAGE, CI_COMMIT_TIMESTAMP, CI_COMMIT_AUTHOR, } = env;
         const { name, email } = parseEmailAndName(CI_COMMIT_AUTHOR);
         tags = {
             [tags_1.CI_JOB_NAME]: GITLAB_CI_JOB_NAME,
@@ -114,7 +114,7 @@ const getCISpanTags = () => {
             [tags_1.CI_PROVIDER_NAME]: exports.CI_ENGINES.GITLAB,
             [tags_1.CI_WORKSPACE_PATH]: CI_PROJECT_DIR,
             [tags_1.CI_STAGE_NAME]: CI_JOB_STAGE,
-            [tags_1.GIT_BRANCH]: CI_COMMIT_BRANCH,
+            [tags_1.GIT_BRANCH]: CI_COMMIT_REF_NAME,
             [tags_1.GIT_SHA]: CI_COMMIT_SHA,
             [tags_1.GIT_REPOSITORY_URL]: CI_REPOSITORY_URL,
             [tags_1.GIT_TAG]: CI_COMMIT_TAG,
@@ -333,7 +333,7 @@ const getCIMetadata = () => {
                 },
             },
             git: {
-                branch: env.CI_COMMIT_BRANCH,
+                branch: env.CI_COMMIT_REF_NAME,
                 commitSha: env.CI_COMMIT_SHA,
             },
         };

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;

package/dist/helpers/tags.d.ts

@@ -0,0 +1,28 @@
+export declare const CI_PIPELINE_URL = "ci.pipeline.url";
+export declare const CI_PROVIDER_NAME = "ci.provider.name";
+export declare const CI_PIPELINE_ID = "ci.pipeline.id";
+export declare const CI_PIPELINE_NAME = "ci.pipeline.name";
+export declare const CI_PIPELINE_NUMBER = "ci.pipeline.number";
+export declare const CI_WORKSPACE_PATH = "ci.workspace_path";
+export declare const GIT_REPOSITORY_URL = "git.repository_url";
+export declare const CI_JOB_URL = "ci.job.url";
+export declare const CI_JOB_NAME = "ci.job.name";
+export declare const CI_STAGE_NAME = "ci.stage.name";
+export declare const CI_LEVEL = "_dd.ci.level";
+export declare const CI_BUILD_LEVEL = "_dd.ci.build_level";
+export declare const GIT_BRANCH = "git.branch";
+export declare const GIT_COMMIT_AUTHOR_DATE = "git.commit.author.date";
+export declare const GIT_COMMIT_AUTHOR_EMAIL = "git.commit.author.email";
+export declare const GIT_COMMIT_AUTHOR_NAME = "git.commit.author.name";
+export declare const GIT_COMMIT_COMMITTER_DATE = "git.commit.committer.date";
+export declare const GIT_COMMIT_COMMITTER_EMAIL = "git.commit.committer.email";
+export declare const GIT_COMMIT_COMMITTER_NAME = "git.commit.committer.name";
+export declare const GIT_COMMIT_MESSAGE = "git.commit.message";
+export declare const GIT_SHA = "git.commit.sha";
+export declare const GIT_TAG = "git.tag";
+export declare const SPAN_TYPE = "span.type";
+/**
+ * Receives an array of the form ['key:value', 'key2:value2']
+ * and returns an object of the form {key: 'value', key2: 'value2'}
+ */
+export declare const parseTags: (tags: string[]) => {};

package/dist/helpers/upload.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+import FormData from 'form-data';
+import { ReadStream } from 'fs';
+import { ApiKeyValidator } from './apikey';
+import { RequestBuilder } from './interfaces';
+/** Multipart payload destined to be sent to Datadog's API
+ */
+export interface MultipartPayload {
+    content: Map<string, MultipartValue>;
+}
+export interface MultipartValue {
+    options?: FormData.AppendOptions | string;
+    value: string | ReadStream;
+}
+export interface UploadOptions {
+    /** ApiKeyValidator (optional) throws an InvalidConfigurationException when upload fails because
+     * of an invalid API key. Callers should most likely catch this exception and display it as a
+     * nice error message.
+     */
+    apiKeyValidator?: ApiKeyValidator;
+    /** Retries is the amount of upload retries before giving up. Some requests are never retried
+     * (400, 413).
+     */
+    retries: number;
+    /** Callback when upload fails (retries are not considered as failure)
+     */
+    onError(error: Error): void;
+    /** Callback to execute before retries
+     */
+    onRetry(error: Error, attempts: number): void;
+    /** Callback to execute before upload.
+     */
+    onUpload(): void;
+}
+export declare enum UploadStatus {
+    Success = 0,
+    Failure = 1,
+    Skipped = 2
+}
+/** Upload a MultipartPayload to Datadog's API using the provided RequestBuilder.
+ * This handles retries as well as logging information about upload if a logger is provided in
+ * the options
+ */
+export declare const upload: (requestBuilder: RequestBuilder) => (payload: MultipartPayload, opts: UploadOptions) => Promise<UploadStatus>;

package/dist/helpers/upload.js

@@ -13,9 +13,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.upload = exports.UploadStatus = void 0;
-const async_retry_1 = __importDefault(require("async-retry"));
 const form_data_1 = __importDefault(require("form-data"));
-const errorCodesNoRetry = [400, 403, 413];
+const retry_1 = require("./retry");
 var UploadStatus;
 (function (UploadStatus) {
     UploadStatus[UploadStatus["Success"] = 0] = "Success";
@@ -29,10 +28,10 @@ var UploadStatus;
 const upload = (requestBuilder) => (payload, opts) => __awaiter(void 0, void 0, void 0, function* () {
     opts.onUpload();
     try {
-        yield uploadWithRetry(requestBuilder, {
+        yield retry_1.retryRequest(() => uploadMultipart(requestBuilder, payload), {
             onRetry: opts.onRetry,
             retries: opts.retries,
-        })(payload);
+        });
         return UploadStatus.Success;
     }
     catch (error) {
@@ -52,31 +51,10 @@ const upload = (requestBuilder) => (payload, opts) => __awaiter(void 0, void 0,
     }
 });
 exports.upload = upload;
-const uploadWithRetry = (requestBuilder, retryOpts) => (payload) => __awaiter(void 0, void 0, void 0, function* () {
-    // Upload function, passed to async-retry
-    const doUpload = (bail) => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            yield uploadMultipart(requestBuilder)(payload);
-        }
-        catch (error) {
-            if (error.response) {
-                // If it's an axios error
-                if (!errorCodesNoRetry.includes(error.response.status)) {
-                    // And a status code that is not excluded from retries, throw the error so that upload is retried
-                    throw error;
-                }
-            }
-            // If it's another error or an axios error we don't want to retry, bail
-            bail(error);
-        }
-    });
-    // Do the actual call
-    return async_retry_1.default(doUpload, retryOpts);
-});
 // Dependency follows-redirects sets a default maxBodyLength of 10 MB https://github.com/follow-redirects/follow-redirects/blob/b774a77e582b97174813b3eaeb86931becba69db/index.js#L391
 // We don't want any hard limit enforced by the CLI, the backend will enforce a max size by returning 413 errors.
 const maxBodyLength = Infinity;
-const uploadMultipart = (request) => (payload) => __awaiter(void 0, void 0, void 0, function* () {
+const uploadMultipart = (request, payload) => __awaiter(void 0, void 0, void 0, function* () {
     const form = new form_data_1.default();
     payload.content.forEach((value, key) => {
         form.append(key, value.value, value.options);

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

@@ -0,0 +1 @@
+export declare const getUserGitMetadata: () => {};

package/dist/helpers/utils.d.ts

@@ -0,0 +1,31 @@
+import { AxiosRequestConfig } from 'axios';
+import ProxyAgent from 'proxy-agent';
+import type { SpanTags } from './interfaces';
+export declare const pick: <T extends object, K extends keyof T>(base: T, keys: K[]) => Partial<T>;
+export declare const getConfig: (configPath: string) => Promise<any>;
+export declare const parseConfigFile: <T>(baseConfig: T, configPath?: string | undefined) => Promise<T>;
+declare type ProxyType = 'http' | 'https' | 'socks' | 'socks4' | 'socks4a' | 'socks5' | 'socks5h' | 'pac+data' | 'pac+file' | 'pac+ftp' | 'pac+http' | 'pac+https';
+export interface ProxyConfiguration {
+    auth?: {
+        password: string;
+        username: string;
+    };
+    host?: string;
+    port?: number;
+    protocol: ProxyType;
+}
+export declare const getProxyUrl: (options?: ProxyConfiguration | undefined) => string;
+export interface RequestOptions {
+    apiKey: string;
+    appKey?: string;
+    baseUrl: string;
+    headers?: Map<string, string>;
+    overrideUrl?: string;
+    proxyOpts?: ProxyConfiguration;
+}
+export declare const getRequestBuilder: (options: RequestOptions) => (args: AxiosRequestConfig) => import("axios").AxiosPromise<any>;
+export declare const getProxyAgent: (proxyOpts?: ProxyConfiguration | undefined) => ReturnType<typeof ProxyAgent>;
+export declare const getApiHostForSite: (site: string) => string;
+export declare const buildPath: (...args: string[]) => string;
+export declare const removeEmptyValues: (tags: SpanTags) => {};
+export {};

package/dist/index.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datadog/datadog-ci",
-  "version": "0.17.4",
+  "version": "0.17.7",
   "description": "Run datadog actions from the CI.",
   "main": "dist/index.js",
   "repository": "https://github.com/DataDog/datadog-ci",
@@ -48,10 +48,10 @@
     "datadog-metrics": "0.9.3",
     "dd-trace": "0.35.1-beta.1",
     "deep-extend": "0.6.0",
-    "fast-xml-parser": "^3.19.0",
+    "fast-xml-parser": "3.19.0",
     "form-data": "3.0.0",
     "glob": "7.1.4",
-    "proxy-agent": "4.0.1",
+    "proxy-agent": "5.0.0",
     "simple-git": "2.31.0",
     "ssh2": "1.4.0",
     "ssh2-streams": "0.4.10",
@@ -79,6 +79,7 @@
     "@types/xml2js": "0.4.9",
     "jest": "27.0.5",
     "jest-environment-node": "27.0.5",
+    "jest-matcher-specific-error": "1.0.0",
     "prettier": "2.0.5",
     "proxy": "1.0.2",
     "ts-jest": "27.0.3",