@datadog/datadog-ci 0.17.8 → 0.17.9

package/dist/commands/lambda/loggroup.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSubscriptionFilterState = exports.hasLogGroup = exports.calculateLogGroupUpdateRequest = exports.applyLogGroupConfig = exports.SubscriptionState = void 0;
+exports.getSubscriptionFilters = exports.getSubscriptionFilterState = exports.hasLogGroup = exports.calculateLogGroupRemoveRequest = exports.calculateLogGroupUpdateRequest = exports.applyLogGroupConfig = exports.SubscriptionState = void 0;
 const constants_1 = require("./constants");
 var SubscriptionState;
 (function (SubscriptionState) {
@@ -18,8 +18,8 @@ var SubscriptionState;
     SubscriptionState[SubscriptionState["WrongDestinationOwned"] = 2] = "WrongDestinationOwned";
     SubscriptionState[SubscriptionState["WrongDestinationUnowned"] = 3] = "WrongDestinationUnowned";
 })(SubscriptionState = exports.SubscriptionState || (exports.SubscriptionState = {}));
-const applyLogGroupConfig = (logs, configuration) => __awaiter(void 0, void 0, void 0, function* () {
-    const { createLogGroupRequest, deleteSubscriptionFilterRequest, subscriptionFilterRequest } = configuration;
+const applyLogGroupConfig = (logs, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const { createLogGroupRequest, deleteSubscriptionFilterRequest, subscriptionFilterRequest } = config;
     if (createLogGroupRequest !== undefined) {
         yield logs.createLogGroup(createLogGroupRequest).promise();
     }
@@ -60,6 +60,21 @@ const calculateLogGroupUpdateRequest = (logs, logGroupName, forwarderARN) => __a
     return config;
 });
 exports.calculateLogGroupUpdateRequest = calculateLogGroupUpdateRequest;
+const calculateLogGroupRemoveRequest = (logs, logGroupName, forwarderARN) => __awaiter(void 0, void 0, void 0, function* () {
+    const config = {
+        logGroupName,
+    };
+    const subscriptionFilters = yield exports.getSubscriptionFilters(logs, logGroupName);
+    const subscriptionToRemove = subscriptionFilters === null || subscriptionFilters === void 0 ? void 0 : subscriptionFilters.find((subscription) => subscription.destinationArn === forwarderARN || subscription.filterName === constants_1.SUBSCRIPTION_FILTER_NAME);
+    if (subscriptionToRemove) {
+        config.deleteSubscriptionFilterRequest = {
+            filterName: subscriptionToRemove.filterName,
+            logGroupName,
+        };
+    }
+    return config;
+});
+exports.calculateLogGroupRemoveRequest = calculateLogGroupRemoveRequest;
 const hasLogGroup = (logs, logGroupName) => __awaiter(void 0, void 0, void 0, function* () {
     const args = {
         logGroupNamePrefix: logGroupName,
@@ -73,7 +88,7 @@ const hasLogGroup = (logs, logGroupName) => __awaiter(void 0, void 0, void 0, fu
 });
 exports.hasLogGroup = hasLogGroup;
 const getSubscriptionFilterState = (logs, logGroupName, forwarderARN) => __awaiter(void 0, void 0, void 0, function* () {
-    const { subscriptionFilters } = yield logs.describeSubscriptionFilters({ logGroupName }).promise();
+    const subscriptionFilters = yield exports.getSubscriptionFilters(logs, logGroupName);
     if (subscriptionFilters === undefined || subscriptionFilters.length === 0) {
         return SubscriptionState.Empty;
     }
@@ -87,3 +102,11 @@ const getSubscriptionFilterState = (logs, logGroupName, forwarderARN) => __await
     return SubscriptionState.WrongDestinationUnowned;
 });
 exports.getSubscriptionFilterState = getSubscriptionFilterState;
+const getSubscriptionFilters = (logs, logGroupName) => __awaiter(void 0, void 0, void 0, function* () {
+    const subscriptionFiltersRequest = {
+        logGroupName,
+    };
+    const { subscriptionFilters } = yield logs.describeSubscriptionFilters(subscriptionFiltersRequest).promise();
+    return subscriptionFilters;
+});
+exports.getSubscriptionFilters = getSubscriptionFilters;

package/dist/commands/lambda/tags.d.ts

@@ -1,7 +1,6 @@
 import { Lambda } from 'aws-sdk';
-export interface TagConfiguration {
-    tagResourceRequest?: Lambda.TagResourceRequest;
-}
-export declare const applyTagConfig: (lambda: Lambda, configuration: TagConfiguration) => Promise<void>;
+import { TagConfiguration } from './interfaces';
+export declare const applyTagConfig: (lambda: Lambda, config: TagConfiguration) => Promise<void>;
 export declare const calculateTagUpdateRequest: (lambda: Lambda, functionARN: string) => Promise<TagConfiguration | undefined>;
+export declare const calculateTagRemoveRequest: (lambda: Lambda, functionARN: string) => Promise<TagConfiguration | undefined>;
 export declare const hasVersionTag: (lambda: Lambda, functionARN: string) => Promise<boolean>;

package/dist/commands/lambda/tags.js

@@ -12,16 +12,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasVersionTag = exports.calculateTagUpdateRequest = exports.applyTagConfig = void 0;
+exports.hasVersionTag = exports.calculateTagRemoveRequest = exports.calculateTagUpdateRequest = exports.applyTagConfig = void 0;
 const path_1 = __importDefault(require("path"));
 const constants_1 = require("./constants");
 // tslint:disable-next-line
 const { version } = require(path_1.default.join(__dirname, '../../../package.json'));
-const applyTagConfig = (lambda, configuration) => __awaiter(void 0, void 0, void 0, function* () {
-    const { tagResourceRequest } = configuration;
+const applyTagConfig = (lambda, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const { tagResourceRequest, untagResourceRequest } = config;
     if (tagResourceRequest !== undefined) {
         yield lambda.tagResource(tagResourceRequest).promise();
     }
+    if (untagResourceRequest !== undefined) {
+        yield lambda.untagResource(untagResourceRequest).promise();
+    }
 });
 exports.applyTagConfig = applyTagConfig;
 const calculateTagUpdateRequest = (lambda, functionARN) => __awaiter(void 0, void 0, void 0, function* () {
@@ -39,6 +42,19 @@ const calculateTagUpdateRequest = (lambda, functionARN) => __awaiter(void 0, voi
     return;
 });
 exports.calculateTagUpdateRequest = calculateTagUpdateRequest;
+const calculateTagRemoveRequest = (lambda, functionARN) => __awaiter(void 0, void 0, void 0, function* () {
+    const config = {};
+    const versionTagPresent = yield exports.hasVersionTag(lambda, functionARN);
+    if (versionTagPresent) {
+        config.untagResourceRequest = {
+            Resource: functionARN,
+            TagKeys: [constants_1.TAG_VERSION_NAME],
+        };
+        return config;
+    }
+    return;
+});
+exports.calculateTagRemoveRequest = calculateTagRemoveRequest;
 const hasVersionTag = (lambda, functionARN) => __awaiter(void 0, void 0, void 0, function* () {
     const args = {
         Resource: functionARN,

package/dist/commands/lambda/uninstrument.d.ts

@@ -0,0 +1,11 @@
+import { Command } from 'clipanion';
+export declare class UninstrumentCommand extends Command {
+    private config;
+    private configPath?;
+    private dryRun;
+    private forwarder?;
+    private functions;
+    private region?;
+    execute(): Promise<1 | 0>;
+    private printPlannedActions;
+}

package/dist/commands/lambda/uninstrument.js

@@ -0,0 +1,127 @@
+"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 });
+exports.UninstrumentCommand = void 0;
+const aws_sdk_1 = require("aws-sdk");
+const chalk_1 = require("chalk");
+const clipanion_1 = require("clipanion");
+const utils_1 = require("../../helpers/utils");
+const commons_1 = require("./functions/commons");
+const uninstrument_1 = require("./functions/uninstrument");
+class UninstrumentCommand extends clipanion_1.Command {
+    constructor() {
+        super(...arguments);
+        this.config = {
+            functions: [],
+            region: process.env.AWS_DEFAULT_REGION,
+        };
+        this.dryRun = false;
+        this.functions = [];
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lambdaConfig = { lambda: this.config };
+            this.config = (yield utils_1.parseConfigFile(lambdaConfig, this.configPath)).lambda;
+            const hasSpecifiedFuntions = this.functions.length !== 0 || this.config.functions.length !== 0;
+            if (!hasSpecifiedFuntions) {
+                this.context.stdout.write('No functions specified for un-instrumentation.\n');
+                return 1;
+            }
+            const functionGroups = commons_1.collectFunctionsByRegion(this.functions.length !== 0 ? this.functions : this.config.functions, this.region || this.config.region);
+            if (functionGroups === undefined) {
+                return 1;
+            }
+            const configGroups = [];
+            // Fetch lambda function configurations that are
+            // available to be un-instrumented.
+            for (const [region, functionList] of Object.entries(functionGroups)) {
+                const lambda = new aws_sdk_1.Lambda({ region });
+                const cloudWatchLogs = new aws_sdk_1.CloudWatchLogs({ region });
+                try {
+                    const configs = yield uninstrument_1.getFunctionConfigs(lambda, cloudWatchLogs, functionList, this.forwarder);
+                    configGroups.push({ configs, lambda, cloudWatchLogs });
+                }
+                catch (err) {
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} Couldn't fetch lambda functions. ${err}\n`);
+                    return 1;
+                }
+            }
+            const configList = configGroups.map((group) => group.configs).reduce((a, b) => a.concat(b));
+            this.printPlannedActions(configList);
+            if (this.dryRun || configList.length === 0) {
+                return 0;
+            }
+            // Un-instrument functions.
+            const promises = Object.values(configGroups).map((group) => {
+                commons_1.updateLambdaFunctionConfigs(group.lambda, group.cloudWatchLogs, group.configs);
+            });
+            try {
+                yield Promise.all(promises);
+            }
+            catch (err) {
+                this.context.stdout.write(`${chalk_1.red('[Error]')} Failure during un-instrumentation. ${err}`);
+                return 1;
+            }
+            return 0;
+        });
+    }
+    printPlannedActions(configs) {
+        var _a;
+        const prefix = this.dryRun ? chalk_1.bold(chalk_1.cyan('[Dry Run] ')) : '';
+        let anyUpdates = false;
+        for (const config of configs) {
+            if (config.updateRequest !== undefined ||
+                ((_a = config.logGroupConfiguration) === null || _a === void 0 ? void 0 : _a.deleteSubscriptionFilterRequest) !== undefined ||
+                (config === null || config === void 0 ? void 0 : config.tagConfiguration) !== undefined) {
+                anyUpdates = true;
+                break;
+            }
+        }
+        if (!anyUpdates) {
+            this.context.stdout.write(`${prefix}No updates will be applied\n`);
+            return;
+        }
+        this.context.stdout.write(`${prefix}Will apply the following updates:\n`);
+        for (const config of configs) {
+            if (config.updateRequest) {
+                this.context.stdout.write(`UpdateFunctionConfiguration -> ${config.functionARN}\n${JSON.stringify(config.updateRequest, undefined, 2)}\n`);
+            }
+            const { logGroupConfiguration, tagConfiguration } = config;
+            if (tagConfiguration === null || tagConfiguration === void 0 ? void 0 : tagConfiguration.untagResourceRequest) {
+                this.context.stdout.write(`UntagResource -> ${tagConfiguration.untagResourceRequest.Resource}\n${JSON.stringify(tagConfiguration.untagResourceRequest.TagKeys, undefined, 2)}\n`);
+            }
+            if (logGroupConfiguration === null || logGroupConfiguration === void 0 ? void 0 : logGroupConfiguration.deleteSubscriptionFilterRequest) {
+                this.context.stdout.write(`DeleteSubscriptionFilter -> ${logGroupConfiguration.logGroupName}\n${JSON.stringify(logGroupConfiguration.deleteSubscriptionFilterRequest, undefined, 2)}\n`);
+            }
+        }
+    }
+}
+exports.UninstrumentCommand = UninstrumentCommand;
+UninstrumentCommand.addPath('lambda', 'uninstrument');
+UninstrumentCommand.addOption('functions', clipanion_1.Command.Array('-f,--function'));
+UninstrumentCommand.addOption('region', clipanion_1.Command.String('-r,--region'));
+UninstrumentCommand.addOption('configPath', clipanion_1.Command.String('--config'));
+UninstrumentCommand.addOption('dryRun', clipanion_1.Command.Boolean('-d,--dry'));
+UninstrumentCommand.addOption('forwarder', clipanion_1.Command.String('--forwarder'));
+/**
+ * Commands that are not really in use, but to
+ * make uninstrumentation easier for the user.
+ */
+UninstrumentCommand.addOption('extensionVersion', clipanion_1.Command.String('-e,--extensionVersion', { hidden: true }));
+UninstrumentCommand.addOption('layerVersion', clipanion_1.Command.String('-v,--layerVersion', { hidden: true }));
+UninstrumentCommand.addOption('tracing', clipanion_1.Command.String('--tracing', { hidden: true }));
+UninstrumentCommand.addOption('mergeXrayTraces', clipanion_1.Command.String('--mergeXrayTraces', { hidden: true }));
+UninstrumentCommand.addOption('flushMetricsToLogs', clipanion_1.Command.String('--flushMetricsToLogs', { hidden: true }));
+UninstrumentCommand.addOption('logLevel', clipanion_1.Command.String('--logLevel', { hidden: true }));
+UninstrumentCommand.addOption('service', clipanion_1.Command.String('--service', { hidden: true }));
+UninstrumentCommand.addOption('environment', clipanion_1.Command.String('--env', { hidden: true }));
+UninstrumentCommand.addOption('version', clipanion_1.Command.String('--version', { hidden: true }));
+UninstrumentCommand.addOption('extraTags', clipanion_1.Command.String('--extra-tags', { hidden: true }));

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datadog/datadog-ci",
-  "version": "0.17.8",
+  "version": "0.17.9",
   "description": "Run datadog actions from the CI.",
   "main": "dist/index.js",
   "repository": "https://github.com/DataDog/datadog-ci",

package/dist/commands/lambda/function.d.ts

@@ -1,43 +0,0 @@
-import { CloudWatchLogs, Lambda } from 'aws-sdk';
-import { Runtime } from './constants';
-import { LogGroupConfiguration } from './loggroup';
-import { TagConfiguration } from './tags';
-export interface FunctionConfiguration {
-    functionARN: string;
-    lambdaConfig: Lambda.FunctionConfiguration;
-    lambdaLibraryLayerArn: string;
-    logGroupConfiguration?: LogGroupConfiguration;
-    tagConfiguration?: TagConfiguration;
-    updateRequest?: Lambda.UpdateFunctionConfigurationRequest;
-}
-interface InstrumentationTags {
-    environment?: string;
-    extraTags?: string;
-    service?: string;
-    version?: string;
-}
-export interface InstrumentationSettings extends InstrumentationTags {
-    extensionVersion?: number;
-    flushMetricsToLogs: boolean;
-    forwarderARN?: string;
-    layerAWSAccount?: string;
-    layerVersion?: number;
-    logLevel?: string;
-    mergeXrayTraces: boolean;
-    tracingEnabled: boolean;
-}
-export declare const getLambdaConfigs: (lambda: Lambda, cloudWatch: CloudWatchLogs, region: string, functionARNs: string[], settings: InstrumentationSettings) => Promise<FunctionConfiguration[]>;
-export declare const getLambdaConfigsFromRegEx: (lambda: Lambda, cloudWatch: CloudWatchLogs, region: string, pattern: string, settings: InstrumentationSettings) => Promise<FunctionConfiguration[]>;
-export declare const updateLambdaConfigs: (lambda: Lambda, cloudWatch: CloudWatchLogs, configurations: FunctionConfiguration[]) => Promise<void>;
-export declare const getFunctionConfiguration: (lambda: Lambda, cloudWatch: CloudWatchLogs, config: Lambda.FunctionConfiguration, region: string, settings: InstrumentationSettings) => Promise<{
-    functionARN: string;
-    lambdaConfig: Lambda.FunctionConfiguration;
-    lambdaLibraryLayerArn: string;
-    logGroupConfiguration: LogGroupConfiguration | undefined;
-    tagConfiguration: TagConfiguration | undefined;
-    updateRequest: Lambda.UpdateFunctionConfigurationRequest | undefined;
-}>;
-export declare const getLayerArn: (runtime: Runtime, settings: InstrumentationSettings, region: string) => string;
-export declare const getExtensionArn: (settings: InstrumentationSettings, region: string) => string;
-export declare const calculateUpdateRequest: (config: Lambda.FunctionConfiguration, settings: InstrumentationSettings, lambdaLibraryLayerArn: string, lambdaExtensionLayerArn: string, runtime: Runtime) => Lambda.UpdateFunctionConfigurationRequest | undefined;
-export {};