serverless-plugin-datadog 5.0.1 → 5.1.2

package/README.md

@@ -1,11 +1,3 @@
----
-title: Datadog Serverless Plugin
-kind: documentation
-aliases:
-  - /serverless/serverless_integrations/plugin/
-dependencies: ["https://github.com/DataDog/serverless-plugin-datadog/blob/master/README.md"]
----
-
 ![build](https://github.com/DataDog/serverless-plugin-datadog/workflows/build/badge.svg)
 [![Code Coverage](https://img.shields.io/codecov/c/github/DataDog/serverless-plugin-datadog)](https://codecov.io/gh/DataDog/serverless-plugin-datadog)
 [![NPM](https://img.shields.io/npm/v/serverless-plugin-datadog)](https://www.npmjs.com/package/serverless-plugin-datadog)
@@ -21,72 +13,71 @@ The plugin automatically enables instrumentation for applications to collect met
 
 ## Getting started
 
-To quickly get started, follow the installation instructions for [Python][1], [Node.js][2], [Ruby][3], [Java][4], [Go][5], or [.NET][6] and view your function's enhanced metrics, traces, and logs in Datadog. These instructions will get you a basic working setup. If working in Ruby or Go, further code changes are required.
+To quickly get started, follow the installation instructions for [Python][1], [Node.js][2], [Ruby][3], [Java][4], [Go][5], or [.NET][6] and view your function's enhanced metrics, traces, and logs in Datadog.
+
+After installation is complete, configure the [advanced options](https://docs.datadoghq.com/serverless/configuration) to suit your monitoring needs.
 
 ## Upgrade
 
 Each version of the plugin is published with a [specific set of versions of the Datadog Lambda layers][15]. To pick up new features and bug fixes provided by the latest versions of Datadog Lambda layers, upgrade the serverless framework plugin. Test the new version before applying it on your production applications.
 
-## More configuration options
+## Configuration parameters
 
 To further configure your plugin, use the following custom parameters in your `serverless.yml`:
 
 | Parameter                     | Description                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `flushMetricsToLogs`          | Send custom metrics by using logs with the Datadog Forwarder Lambda function (recommended). Defaults to `true`. To use an encrypted key, set `apiKMSKey` or `apiKeySecretArn` in the configuration. `flushMetricsToLogs` is ignored when `addExtension` is true.                                                                                                                                                                    |
-| `site`                        | Set which Datadog site to send data to. This is only used when `flushMetricsToLogs` is `false` or `addExtension` is `true`. Possible values are `datadoghq.com`, `datadoghq.eu`, `us3.datadoghq.com`, `us5.datadoghq.com`, and `ddog-gov.com`. The default is `datadoghq.com`.                                                                                                                                                      |
-| `apiKey`                      | Datadog API key. Required when `flushMetricsToLogs` is `false` or `addExtension` is `true`. Defining `apiKey` adds the Datadog API key directly to your Lambda functions as an environment variable. For more information about getting a Datadog API key, see the [API key documentation][7]. Can also be set through the `DATADOG_API_KEY` environment variable.                                                                  |
-| `appKey`                      | Datadog app key. Only needed when the `monitors` field is defined. Can also be set through the `DATADOG_APP_KEY` environment variable.                                                                                                                                                                                                                                                                                              |
-| `apiKeySecretArn`             | An alternative to using the `apiKey` field. The ARN of the secret storing the Datadog API key in AWS Secrets Manager. Use this parameter if you're storing your secrets in AWS Secrets Manager, and when `flushMetricsToLogs` is `false` or `addExtension` is `true`. If set, remember to add the `secretsmanager:GetSecretValue` permission to the Lambda execution role.                                                          |
-| `apiKMSKey`                   | An alternative to using the `apiKey` field. Datadog API key encrypted using KMS. Use this parameter if you're storing your secrets with KMS, and if `flushMetricsToLogs` is `false` or `addExtension` is `true`. Defining `apiKMSKey` adds the Datadog API Key directly to your Lambda functions as an environment variable.                                                                                                        |
-| `captureLambdaPayload`        | (Experimental) This optional setting configures Datadog ingestion for incoming and outgoing AWS Lambda payloads. Function request and response values are added as part of outgoing APM spans sent to Datadog, and require Datadog APM to be configured on your function. You can obfuscate fields in the Lambda payload by using the `replace_tags` block within `apm_config` settings in [datadog.yaml.][16] Defaults to `false`. |
-| `addLayers`                   | Whether to install the Datadog Lambda library as a layer. Defaults to `true`. Set to `false` when you plan to package the Datadog Lambda library to your function's deployment package on your own so that you can install a specific version of the Datadog Lambda library ([Python][8] or [Node.js][9]).                                                                                                                          |
-| `addExtension`                | Whether to install the Datadog Lambda Extension as a layer. Defaults to `true`. When enabled, it's required to set the environment variable `DATADOG_API_KEY`, or the configuration values `apiKMSKey` or `apiKeySecretArn`. Learn more about the [Datadog Lambda Extension Layer][12] in the documentation. **Note:** AWS only supports Lambda Extensions for [certain runtimes][13].                                              |
-| `logLevel`                    | The log level, set to `DEBUG` for extended logging.                                                                                                                                                                                                                                                                                                                                                                                 |
-| `enableXrayTracing`           | Set `true` to enable X-Ray tracing on the Lambda functions and API Gateway integrations. Defaults to `false`.                                                                                                                                                                                                                                                                                                                       |
-| `enableDDTracing`             | Enable Datadog tracing on the Lambda function. Note: This applies only to integrations using the Datadog Extension. Defaults to `true`.                                                                                                                                                                                                                                                                                             |
-| `enableDDLogs`                | Enable Datadog log collection for the Lambda function. Note: This setting has no effect on logs sent by the Datadog Forwarder. Defaults to `true`.                                                                                                                                                                                                                                                                                  |
-| `enableSourceCodeIntegration` | Enable Datadog source code integration for the function. This feature links your Github repository information to the function in Datadog and allows you to view stack traces from Datadog directly in Github. For more information, see [Source Code Integration](https://docs.datadoghq.com/integrations/guide/source-code-integration).                                                                                          |
-| `subscribeToApiGatewayLogs`   | Enable automatic subscription of the Datadog Forwarder to API Gateway log groups. Defaults to `true`.                                                                                                                                                                                                                                                                                                                               |
-| `subscribeToHttpApiLogs`      | Enable automatic subscription of the Datadog Forwarder to HTTP API log groups. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                  |
-| `subscribeToWebsocketLogs`    | Enable automatic subscription of the Datadog Forwarder to WebSocket log groups. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                 |
-| `forwarderArn`                | Setting this parameter subscribes the given Datadog forwarder to the Lambda functions’ CloudWatch log groups. Required when `enableDDTracing` is set to `true` unless the subscription is otherwise applied. For example, if a Datadog Forwarder subscription is applied using Datadog's AWS Integration, then `forwarderArn` is not required.                                                                                      |
-| `integrationTesting`          | Set `true` when running integration tests. This bypasses the validation of the Forwarder ARN and the addition of Datadog Monitor output links. Defaults to `false`.                                                                                                                                                                                                                                                                 |
-| `enableTags`                  | When set, automatically tag the Lambda functions with the `service` and `env` tags using the `service` and `stage` values from the serverless application definition. It does NOT override if a `service` or `env` tag already exists. Defaults to `true`.                                                                                                                                                                          |
-| `injectLogContext`            | When set, the Lambda layer automatically patches `console.log` with Datadog's tracing IDs. Defaults to `true`.                                                                                                                                                                                                                                                                                                                      |
-| `exclude`                     | When set, this plugin ignores all specified functions. Use this parameter if you have any functions that should not include Datadog functionality. Defaults to `[]`.                                                                                                                                                                                                                                                                |
-| `enabled`                     | When set to `false`, the Datadog plugin stays inactive. Defaults to `true`. You can control this option using an environment variable. For example, use `enabled: ${strToBool(${env:DD_PLUGIN_ENABLED, true})}` to activate/deactivate the plugin during deployment. Alternatively, you can also use the value passed in through `--stage` to control this option—[see example](#disable-plugin-for-particular-environment).        |
-| `monitors`                    | When defined, the Datadog plugin will configure monitors for the deployed function. Requires setting `DATADOG_API_KEY` and `DATADOG_APP_KEY` in your environment. To learn how to define monitors, see [To Enable and Configure a Recommended Serverless Monitor](#to-enable-and-configure-a-recommended-serverless-monitor).                                                                                                       |
-| `customHandler`               | When set, the specified handler is set as the handler for all the functions. By default, the handler is set to `/opt/nodejs/node_modules/datadog-lambda-js/handler.handler` if `addLayers` is set to `true`, or `node_modules/datadog-lambda-js/dist/handler.handler` if `addLayers` is set to `false`.                                                                                                                             |
-| `failOnError`                 | When set, this plugin will throw an error if any custom Datadog monitors fail to create or update. This occurs after deploy, but will cause the result of `serverless deploy` to return a nonzero exit code (to fail user CI). Defaults to `false`.                                                                                                                                                                                 |
+| `site`                        | Set which Datadog site to send data to, such as `datadoghq.com` (default), `datadoghq.eu`, `us3.datadoghq.com`, `us5.datadoghq.com`, or `ddog-gov.com`. This parameter is required when collecting telemtry using the Datadog Lambda Extension. |
+| `apiKey`                      | [Datadog API key][7]. This parameter is required when collecting telemetry using the Datadog Lambda Extension. Alternatively, you can also set the `DATADOG_API_KEY` environment variable in your deployment environment. |
+| `appKey`                      | Datadog app key. Only needed when the `monitors` field is defined. Alternatively, you can also set the `DATADOG_APP_KEY` environment variable in your deployment environment. |
+| `apiKeySecretArn`             | An alternative to using the `apiKey` field. The ARN of the secret that is storing the Datadog API key in AWS Secrets Manager. Remember to add the `secretsmanager:GetSecretValue` permission to the Lambda execution role. |
+| `apiKMSKey`                   | An alternative to using the `apiKey` field. Datadog API key encrypted using KMS. Remember to add the `kms:Decrypt` permission to the Lambda execution role. |
+| `env`                         | When set along with `addExtension`, a `DD_ENV` environment variable is added to all Lambda functions with the provided value. Otherwise, an `env` tag is added to all Lambda functions with the provided value. Defaults to the `stage` value of the serverless deployment. |
+| `service`                     | When set along with `addExtension`, a `DD_SERVICE` environment variable is added to all Lambda functions with the provided value. Otherwise, a `service` tag is added to all Lambda functions with the provided value. Defaults to the `service` value of the serverless project.
+| `version`                     | When set along with `addExtension`, a `DD_VERSION` environment variable is added to all Lambda functions with the provided value. When set along with `forwarderArn`, a `version` tag is added to all Lambda functions with the provided value. |
+| `tags`                        | A comma separated list of `key`:`value` pairs as a single string. When set along with `extensionLayerVersion`, a `DD_TAGS` environment variable is added to all Lambda functions with the provided value. When set along with `forwarderArn`, the plugin parses the string and sets each `key`:`value` pair as a tag on all Lambda functions. |
+| `enableXrayTracing`           | Set `true` to enable X-Ray tracing on the Lambda functions and API Gateway integrations. Defaults to `false`. |
+| `enableDDTracing`             | Enable Datadog tracing on the Lambda function. Defaults to `true`. |
+| `enableDDLogs`                | Enable Datadog log collection using the Lambda Extension. Defaults to `true`. Note: This setting has no effect on logs sent by the Datadog Forwarder. |
+| `monitors`                    | When defined, the Datadog plugin configures monitors for the deployed function. Requires setting `DATADOG_API_KEY` and `DATADOG_APP_KEY` in your environment. To learn how to define monitors, see [To Enable and Configure a Recommended Serverless Monitor](#to-enable-and-configure-a-recommended-serverless-monitor). |
+| `captureLambdaPayload`        | [Captures incoming and outgoing AWS Lambda payloads][17] in the Datadog APM spans for Lambda invocations. Defaults to `false`. |
+| `enableSourceCodeIntegration` | Enable [Datadog source code integration][18] for the function. Defaults to `true`. |
+| `subscribeToApiGatewayLogs`   | Enable automatic subscription of the Datadog Forwarder to API Gateway log groups. Requires setting `forwarderArn`. Defaults to `true`. |
+| `subscribeToHttpApiLogs`      | Enable automatic subscription of the Datadog Forwarder to HTTP API log groups. Requires setting `forwarderArn`. Defaults to `true`. |
+| `subscribeToWebsocketLogs`    | Enable automatic subscription of the Datadog Forwarder to WebSocket log groups. Requires setting `forwarderArn`. Defaults to `true`. |
+| `forwarderArn`                | The ARN of the Datadog Forwarder to be subscribed to the Lambda or API Gateway log groups. |
+| `addLayers`                   | Whether to install the Datadog Lambda library as a layer. Defaults to `true`. Set to `false` when you plan to package the Datadog Lambda library to your function's deployment package on your own so that you can install a specific version of the Datadog Lambda library ([Python][8] or [Node.js][9]). |
+| `addExtension`                | Whether to install the Datadog Lambda Extension as a layer. Defaults to `true`. When enabled, it's required to set the `apiKey` and `site`. |
+| `exclude`                     | When set, this plugin ignores all specified functions. Use this parameter if you have any functions that should not include Datadog functionality. Defaults to `[]`. |
+| `enabled`                     | When set to `false`, the Datadog plugin stays inactive. Defaults to `true`. You can control this option using an environment variable. For example, use `enabled: ${strToBool(${env:DD_PLUGIN_ENABLED, true})}` to activate/deactivate the plugin during deployment. Alternatively, you can also use the value passed in through `--stage` to control this option—[see example](#disable-plugin-for-particular-environment). |
+| `customHandler`               | When set, the specified handler is set as the handler for all the functions. |
+| `failOnError`                 | When set, this plugin throws an error if any custom Datadog monitors fail to create or update. This occurs after deploy, but will cause the result of `serverless deploy` to return a nonzero exit code (to fail user CI). Defaults to `false`. |
+| `integrationTesting`          | Set `true` when running integration tests. This bypasses the validation of the Forwarder ARN and the addition of Datadog Monitor output links. Defaults to `false`. |
+| `logLevel`                    | The log level, set to `DEBUG` for extended logging. |
 
 To use any of these parameters, add a `custom` > `datadog` section to your `serverless.yml` similar to this example:
 
 ```yaml
 custom:
   datadog:
-    flushMetricsToLogs: true
     apiKeySecretArn: "{Datadog_API_Key_Secret_ARN}"
-    apiKMSKey: "{Encrypted_Datadog_API_Key}"
-    addLayers: true
-    logLevel: "info"
     enableXrayTracing: false
     enableDDTracing: true
     enableDDLogs: true
     subscribeToAccessLogs: true
     forwarderArn: arn:aws:lambda:us-east-1:000000000000:function:datadog-forwarder
-    enableTags: true
-    injectLogContext: true
     exclude:
       - dd-excluded-function
 ```
 
-**Note**: If you use webpack, Datadog recommends using the prebuilt layers by setting `addLayers` to `true`, which is the default, and add `datadog-lambda-js` and `dd-trace` to the [externals][10] section of your webpack config.
+### Webpack
 
-**Note**: Many of the above configuration values require setting `DATADOG_API_KEY` in your environment. If you store these values in AWS Secrets Manager or AWS KMS, refer to the above options `apiKeySecretArn` and `apiKMSKey` to pull your Datadog API key from the correct location.
+If you are using a bundler, such as webpack, see [Serverless Tracing and Webpack](https://docs.datadoghq.com/serverless/guide/serverless_tracing_and_webpack/).
 
 ### TypeScript
 
+You may encounter the error of missing type definitions. To resolve the error, add `datadog-lambda-js` and `dd-trace` to the `devDependencies` list of your project's package.json.
+
 If you are using serverless-typescript, make sure that `serverless-datadog` is above the `serverless-typescript` entry in your `serverless.yml`. The plugin will automatically detect `.ts` files.
 
 ```yaml
@@ -95,49 +86,6 @@ plugins:
   - serverless-typescript
 ```
 
-If you use TypeScript, you may encounter the error of missing type definitions. A missing type definition happens when you use the prebuilt layers (for example, set `addLayers` to `true`, which is the default) and need to import helper functions from the `datadog-lambda-js` and `dd-trace` packages to submit custom metrics or instrument a specific function. To resolve the error, add `datadog-lambda-js` and `dd-trace` to the `devDependencies` list of your project's package.json.
-
-### Webpack
-
-`dd-trace` is known to be not compatible with webpack due to the use of conditional import and other issues. If using webpack, make sure to mark `datadog-lambda-js` and `dd-trace` as [externals](https://webpack.js.org/configuration/externals/) for webpack, so webpack knows these dependencies will be available in the runtime. You should also remove `datadog-lambda-js` and `dd-trace` from `package.json` and the build process to ensure you're using the versions provided by the Datadog Lambda Layer.
-
-#### serverless-webpack
-
-If using `serverless-webpack`, make sure to also exclude `datadog-lambda-js` and `dd-trace` in your `serverless.yml` in addition to declaring them as external in your webpack config file.
-
-**webpack.config.js**
-
-```javascript
-var nodeExternals = require("webpack-node-externals");
-
-module.exports = {
-  // we use webpack-node-externals to excludes all node deps.
-  // You can manually set the externals too.
-  externals: [nodeExternals(), "dd-trace", "datadog-lambda-js"],
-};
-```
-
-**serverless.yml**
-
-```yaml
-custom:
-  webpack:
-    includeModules:
-      forceExclude:
-        - dd-trace
-        - datadog-lambda-js
-```
-
-### Forwarder
-
-The [Datadog Forwarder Lambda function][11] needs to be installed and subscribed to your Lambda functions' log groups. The plugin automatically creates the log subscriptions when the Forwarder's ARN is supplied via the `forwarderArn` option.
-
-If you run into the following error, double check the supplied Forwarder ARN is correct and ensure it is from the same region and account where your serverless application is deployed.
-
-```
-An error occurred: GetaccountapiLogGroupSubscription - Could not execute the lambda function. Make sure you have given CloudWatch Logs permission to execute your function. (Service: AWSLogs; Status Code: 400; Error Code: InvalidParameterException).
-```
-
 ### Disable Plugin for Particular Environment
 
 If you'd like to turn off the plugin based on the environment (passed via `--stage`), you can use something similar to the example below.
@@ -246,9 +194,8 @@ custom:
 
 ### [v5.0.0](https://github.com/DataDog/serverless-plugin-datadog/releases/tag/v5.0.0)
 
-- This plugin stops setting tags for Service and ENV, and instead uses environment variables (when used in conjunction with the Datadog Extension).
-
-v5.0 is compatible with v10+ of the Datadog Extension, and all version of the Datadog Forwarder.
+- When used in conjunction with the Datadog Extension, this plugin sets `service` and `env` tags through environment variables instead of Lambda resource tags.
+- The `enableTags` parameter was replaced by the new `service`, `env` parameters.
 
 ### [v4.0.0](https://github.com/DataDog/serverless-plugin-datadog/releases/tag/v4.0.0)
 
@@ -292,3 +239,5 @@ This product includes software developed at Datadog (<https://www.datadoghq.com/
 [14]: https://github.com/DataDog/serverless-plugin-datadog/blob/master/CONTRIBUTING.md
 [15]: https://github.com/DataDog/serverless-plugin-datadog/blob/master/src/layers.json
 [16]: https://docs.datadoghq.com/tracing/setup_overview/configure_data_security/?tab=mongodb#replace-rules-for-tag-filtering
+[17]: https://www.datadoghq.com/blog/troubleshoot-lambda-function-request-response-payloads/
+[18]: https://docs.datadoghq.com/integrations/guide/source-code-integration

package/dist/env.d.ts

@@ -0,0 +1,17 @@
+import Service from "serverless/classes/Service";
+export interface Configuration {
+    addLayers: boolean;
+    apiKey?: string;
+    apiKMSKey?: string;
+    site: string;
+    logLevel: string;
+    flushMetricsToLogs: boolean;
+    enableXrayTracing: boolean;
+    enableDDTracing: boolean;
+    forwarder?: string;
+    enableTags: boolean;
+}
+export declare const defaultConfiguration: Configuration;
+export declare function setEnvConfiguration(config: Configuration, service: Service): void;
+export declare function getConfig(service: Service): Configuration;
+//# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAQA,OAAO,OAAO,MAAM,4BAA4B,CAAC;AAEjD,MAAM,WAAW,aAAa;IAE5B,SAAS,EAAE,OAAO,CAAC;IAEnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,IAAI,EAAE,MAAM,CAAC;IAEb,QAAQ,EAAE,MAAM,CAAC;IAEjB,kBAAkB,EAAE,OAAO,CAAC;IAE5B,iBAAiB,EAAE,OAAO,CAAC;IAE3B,eAAe,EAAE,OAAO,CAAC;IAGzB,SAAS,CAAC,EAAE,MAAM,CAAC;IAInB,UAAU,EAAE,OAAO,CAAC;CACrB;AASD,eAAO,MAAM,oBAAoB,EAAE,aAQlC,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,QAyB1E;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,aAAa,CAczD"}

package/dist/env.js

@@ -0,0 +1,63 @@
+"use strict";
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed
+ * under the Apache License Version 2.0.
+ *
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019 Datadog, Inc.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const apiKeyEnvVar = "DD_API_KEY";
+const apiKeyKMSEnvVar = "DD_KMS_API_KEY";
+const siteURLEnvVar = "DD_SITE";
+const logLevelEnvVar = "DD_LOG_LEVEL";
+const logForwardingEnvVar = "DD_FLUSH_TO_LOG";
+const ddTracingEnabledEnvVar = "DD_TRACE_ENABLED";
+exports.defaultConfiguration = {
+    addLayers: true,
+    flushMetricsToLogs: true,
+    logLevel: "info",
+    site: "datadoghq.com",
+    enableXrayTracing: false,
+    enableDDTracing: true,
+    enableTags: true,
+};
+function setEnvConfiguration(config, service) {
+    const provider = service.provider;
+    if (provider.environment === undefined) {
+        provider.environment = {};
+    }
+    const environment = provider.environment;
+    if (config.apiKey !== undefined && environment[apiKeyEnvVar] === undefined) {
+        environment[apiKeyEnvVar] = config.apiKey;
+    }
+    if (config.apiKMSKey !== undefined && environment[apiKeyKMSEnvVar] === undefined) {
+        environment[apiKeyKMSEnvVar] = config.apiKMSKey;
+    }
+    if (environment[siteURLEnvVar] === undefined) {
+        environment[siteURLEnvVar] = config.site;
+    }
+    if (environment[logLevelEnvVar] === undefined) {
+        environment[logLevelEnvVar] = config.logLevel;
+    }
+    if (environment[logForwardingEnvVar] === undefined) {
+        environment[logForwardingEnvVar] = config.flushMetricsToLogs;
+    }
+    if (config.enableDDTracing !== undefined && environment[ddTracingEnabledEnvVar] === undefined) {
+        environment[ddTracingEnabledEnvVar] = config.enableDDTracing;
+    }
+}
+exports.setEnvConfiguration = setEnvConfiguration;
+function getConfig(service) {
+    let custom = service.custom;
+    if (custom === undefined) {
+        custom = {};
+    }
+    let datadog = custom.datadog;
+    if (datadog === undefined) {
+        datadog = {};
+    }
+    return Object.assign(Object.assign({}, exports.defaultConfiguration), datadog);
+}
+exports.getConfig = getConfig;
+//# sourceMappingURL=env.js.map

package/dist/env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.js","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AA8BH,MAAM,YAAY,GAAG,YAAY,CAAC;AAClC,MAAM,eAAe,GAAG,gBAAgB,CAAC;AACzC,MAAM,aAAa,GAAG,SAAS,CAAC;AAChC,MAAM,cAAc,GAAG,cAAc,CAAC;AACtC,MAAM,mBAAmB,GAAG,iBAAiB,CAAC;AAC9C,MAAM,sBAAsB,GAAG,kBAAkB,CAAC;AAErC,QAAA,oBAAoB,GAAkB;IACjD,SAAS,EAAE,IAAI;IACf,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE,MAAM;IAChB,IAAI,EAAE,eAAe;IACrB,iBAAiB,EAAE,KAAK;IACxB,eAAe,EAAE,IAAI;IACrB,UAAU,EAAE,IAAI;CACjB,CAAC;AAEF,SAAgB,mBAAmB,CAAC,MAAqB,EAAE,OAAgB;IACzE,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAe,CAAC;IAEzC,IAAI,QAAQ,CAAC,WAAW,KAAK,SAAS,EAAE;QACtC,QAAQ,CAAC,WAAW,GAAG,EAAE,CAAC;KAC3B;IACD,MAAM,WAAW,GAAG,QAAQ,CAAC,WAAkB,CAAC;IAChD,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,IAAI,WAAW,CAAC,YAAY,CAAC,KAAK,SAAS,EAAE;QAC1E,WAAW,CAAC,YAAY,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;KAC3C;IACD,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS,IAAI,WAAW,CAAC,eAAe,CAAC,KAAK,SAAS,EAAE;QAChF,WAAW,CAAC,eAAe,CAAC,GAAG,MAAM,CAAC,SAAS,CAAC;KACjD;IACD,IAAI,WAAW,CAAC,aAAa,CAAC,KAAK,SAAS,EAAE;QAC5C,WAAW,CAAC,aAAa,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC;KAC1C;IACD,IAAI,WAAW,CAAC,cAAc,CAAC,KAAK,SAAS,EAAE;QAC7C,WAAW,CAAC,cAAc,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC;KAC/C;IACD,IAAI,WAAW,CAAC,mBAAmB,CAAC,KAAK,SAAS,EAAE;QAClD,WAAW,CAAC,mBAAmB,CAAC,GAAG,MAAM,CAAC,kBAAkB,CAAC;KAC9D;IACD,IAAI,MAAM,CAAC,eAAe,KAAK,SAAS,IAAI,WAAW,CAAC,sBAAsB,CAAC,KAAK,SAAS,EAAE;QAC7F,WAAW,CAAC,sBAAsB,CAAC,GAAG,MAAM,CAAC,eAAe,CAAC;KAC9D;AACH,CAAC;AAzBD,kDAyBC;AAED,SAAgB,SAAS,CAAC,OAAgB;IACxC,IAAI,MAAM,GAAG,OAAO,CAAC,MAAa,CAAC;IACnC,IAAI,MAAM,KAAK,SAAS,EAAE;QACxB,MAAM,GAAG,EAAE,CAAC;KACb;IAED,IAAI,OAAO,GAAG,MAAM,CAAC,OAA6C,CAAC;IACnE,IAAI,OAAO,KAAK,SAAS,EAAE;QACzB,OAAO,GAAG,EAAE,CAAC;KACd;IACD,uCACK,4BAAoB,GACpB,OAAO,EACV;AACJ,CAAC;AAdD,8BAcC"}

package/dist/forwarder.d.ts

@@ -0,0 +1,14 @@
+import Service from "serverless/classes/Service";
+import Aws = require("serverless/plugins/aws/provider/awsProvider");
+export declare function addCloudWatchForwarderSubscriptions(service: Service, aws: Aws, functionArn: string): Promise<string[]>;
+export declare function canSubscribeLogGroup(aws: Aws, logGroupName: string, expectedSubName: string): Promise<boolean>;
+export declare function describeSubscriptionFilters(aws: Aws, logGroupName: string): Promise<{
+    creationTime: number;
+    destinationArn: string;
+    distribution: string;
+    filterName: string;
+    filterPattern: string;
+    logGroupName: string;
+    roleArn: string;
+}[]>;
+//# sourceMappingURL=forwarder.d.ts.map

package/dist/forwarder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forwarder.d.ts","sourceRoot":"","sources":["../src/forwarder.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,4BAA4B,CAAC;AACjD,OAAO,GAAG,GAAG,QAAQ,6CAA6C,CAAC,CAAC;AA4BpE,wBAAsB,mCAAmC,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,qBAuCxG;AAED,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,oBAejG;AAED,wBAAsB,2BAA2B,CAAC,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM;;;;;;;;KAc/E"}

package/dist/forwarder.js

@@ -0,0 +1,87 @@
+"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 logGroupKey = "AWS::Logs::LogGroup";
+const logGroupSubscriptionKey = "AWS::Logs::SubscriptionFilter";
+function isLogGroup(value) {
+    return value.Type === logGroupKey;
+}
+function addCloudWatchForwarderSubscriptions(service, aws, functionArn) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const resources = (_a = service.provider.compiledCloudFormationTemplate) === null || _a === void 0 ? void 0 : _a.Resources;
+        if (resources === undefined) {
+            return ["No cloudformation stack available. Skipping subscribing Datadog forwarder."];
+        }
+        const errors = [];
+        for (const [name, resource] of Object.entries(resources)) {
+            if (!isLogGroup(resource) || !resource.Properties.LogGroupName.startsWith("/aws/lambda/")) {
+                continue;
+            }
+            const logGroupName = resource.Properties.LogGroupName;
+            const scopedSubName = `${name}Subscription`;
+            let expectedSubName = `${service.getServiceName()}-${aws.getStage()}-${scopedSubName}-`;
+            const stackName = aws.naming.getStackName();
+            if (stackName) {
+                expectedSubName = `${stackName}-${scopedSubName}-`;
+            }
+            const canSub = yield canSubscribeLogGroup(aws, logGroupName, expectedSubName);
+            if (!canSub) {
+                errors.push(`Subscription already exists for log group ${logGroupName}. Skipping subscribing Datadog forwarder.`);
+                continue;
+            }
+            const subscription = {
+                Type: logGroupSubscriptionKey,
+                Properties: {
+                    DestinationArn: functionArn,
+                    FilterPattern: "",
+                    LogGroupName: { Ref: name },
+                },
+            };
+            resources[scopedSubName] = subscription;
+        }
+        return errors;
+    });
+}
+exports.addCloudWatchForwarderSubscriptions = addCloudWatchForwarderSubscriptions;
+function canSubscribeLogGroup(aws, logGroupName, expectedSubName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const subscriptionFilters = yield describeSubscriptionFilters(aws, logGroupName);
+        let hasUnknownSubscriptions = false;
+        for (const subscription of subscriptionFilters) {
+            const filterName = subscription.filterName;
+            if (filterName.startsWith(expectedSubName)) {
+                return true;
+            }
+            // We don't own this log group. It might not be possible to set a forwarder
+            hasUnknownSubscriptions = true;
+        }
+        // No log groups, so it's possible to subscribe.
+        return !hasUnknownSubscriptions;
+    });
+}
+exports.canSubscribeLogGroup = canSubscribeLogGroup;
+function describeSubscriptionFilters(aws, logGroupName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const result = yield aws.request("CloudWatchLogs", "describeSubscriptionFilters", {
+                logGroupName,
+            });
+            return result.subscriptionFilters;
+        }
+        catch (err) {
+            // An error will occur if the log group doesn't exist, so we swallow this and return an empty list.
+            return [];
+        }
+    });
+}
+exports.describeSubscriptionFilters = describeSubscriptionFilters;
+//# sourceMappingURL=forwarder.js.map

package/dist/forwarder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forwarder.js","sourceRoot":"","sources":["../src/forwarder.ts"],"names":[],"mappings":";;;;;;;;;;;AAGA,MAAM,WAAW,GAAG,qBAAqB,CAAC;AAC1C,MAAM,uBAAuB,GAAG,+BAA+B,CAAC;AAqBhE,SAAS,UAAU,CAAC,KAAU;IAC5B,OAAO,KAAK,CAAC,IAAI,KAAK,WAAW,CAAC;AACpC,CAAC;AAED,SAAsB,mCAAmC,CAAC,OAAgB,EAAE,GAAQ,EAAE,WAAmB;;;QACvG,MAAM,SAAS,SAAG,OAAO,CAAC,QAAQ,CAAC,8BAA8B,0CAAE,SAAS,CAAC;QAC7E,IAAI,SAAS,KAAK,SAAS,EAAE;YAC3B,OAAO,CAAC,4EAA4E,CAAC,CAAC;SACvF;QACD,MAAM,MAAM,GAAG,EAAE,CAAC;QAElB,KAAK,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE;YACxD,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,YAAY,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE;gBACzF,SAAS;aACV;YAED,MAAM,YAAY,GAAG,QAAQ,CAAC,UAAU,CAAC,YAAY,CAAC;YACtD,MAAM,aAAa,GAAG,GAAG,IAAI,cAAc,CAAC;YAE5C,IAAI,eAAe,GAAG,GAAG,OAAO,CAAC,cAAc,EAAE,IAAI,GAAG,CAAC,QAAQ,EAAE,IAAI,aAAa,GAAG,CAAC;YAExF,MAAM,SAAS,GAAG,GAAG,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;YAC5C,IAAI,SAAS,EAAE;gBACb,eAAe,GAAG,GAAG,SAAS,IAAI,aAAa,GAAG,CAAC;aACpD;YAED,MAAM,MAAM,GAAG,MAAM,oBAAoB,CAAC,GAAG,EAAE,YAAY,EAAE,eAAe,CAAC,CAAC;YAC9E,IAAI,CAAC,MAAM,EAAE;gBACX,MAAM,CAAC,IAAI,CAAC,6CAA6C,YAAY,2CAA2C,CAAC,CAAC;gBAClH,SAAS;aACV;YAED,MAAM,YAAY,GAAG;gBACnB,IAAI,EAAE,uBAAuB;gBAC7B,UAAU,EAAE;oBACV,cAAc,EAAE,WAAW;oBAC3B,aAAa,EAAE,EAAE;oBACjB,YAAY,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE;iBAC5B;aACF,CAAC;YACF,SAAS,CAAC,aAAa,CAAC,GAAG,YAAY,CAAC;SACzC;QACD,OAAO,MAAM,CAAC;;CACf;AAvCD,kFAuCC;AAED,SAAsB,oBAAoB,CAAC,GAAQ,EAAE,YAAoB,EAAE,eAAuB;;QAChG,MAAM,mBAAmB,GAAG,MAAM,2BAA2B,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;QAEjF,IAAI,uBAAuB,GAAG,KAAK,CAAC;QAEpC,KAAK,MAAM,YAAY,IAAI,mBAAmB,EAAE;YAC9C,MAAM,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC;YAC3C,IAAI,UAAU,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE;gBAC1C,OAAO,IAAI,CAAC;aACb;YACD,2EAA2E;YAC3E,uBAAuB,GAAG,IAAI,CAAC;SAChC;QACD,gDAAgD;QAChD,OAAO,CAAC,uBAAuB,CAAC;IAClC,CAAC;CAAA;AAfD,oDAeC;AAED,SAAsB,2BAA2B,CAAC,GAAQ,EAAE,YAAoB;;QAC9E,IAAI;YACF,MAAM,MAAM,GAAwC,MAAM,GAAG,CAAC,OAAO,CACnE,gBAAgB,EAChB,6BAA6B,EAC7B;gBACE,YAAY;aACb,CACF,CAAC;YACF,OAAO,MAAM,CAAC,mBAAmB,CAAC;SACnC;QAAC,OAAO,GAAG,EAAE;YACZ,mGAAmG;YACnG,OAAO,EAAE,CAAC;SACX;IACH,CAAC;CAAA;AAdD,kEAcC"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { FunctionDefinition } from "serverless";
+export interface ExtendedFunctionDefinition extends FunctionDefinition {
+    tags?: {
+        [key: string]: string;
+    };
+    environment?: {
+        [key: string]: string;
+    };
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGhD,MAAM,WAAW,0BAA2B,SAAQ,kBAAkB;IACpE,IAAI,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACjC,WAAW,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACzC"}

package/dist/index.js

@@ -0,0 +1,161 @@
+"use strict";
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed
+ * under the Apache License Version 2.0.
+ *
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019 Datadog, Inc.
+ */
+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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const layers = __importStar(require("./layers.json"));
+const env_1 = require("./env");
+const layer_1 = require("./layer");
+const tracing_1 = require("./tracing");
+const wrapper_1 = require("./wrapper");
+const forwarder_1 = require("./forwarder");
+var TagKeys;
+(function (TagKeys) {
+    TagKeys["Service"] = "service";
+    TagKeys["Env"] = "env";
+})(TagKeys || (TagKeys = {}));
+module.exports = class ServerlessPlugin {
+    constructor(serverless, _) {
+        this.serverless = serverless;
+        this.hooks = {
+            "after:datadog:clean:init": this.afterPackageFunction.bind(this),
+            "after:datadog:generate:init": this.beforePackageFunction.bind(this),
+            "after:deploy:function:packageFunction": this.afterPackageFunction.bind(this),
+            "after:package:createDeploymentArtifacts": this.afterPackageFunction.bind(this),
+            "after:package:initialize": this.beforePackageFunction.bind(this),
+            "before:deploy:function:packageFunction": this.beforePackageFunction.bind(this),
+            "before:offline:start:init": this.beforePackageFunction.bind(this),
+            "before:step-functions-offline:start": this.beforePackageFunction.bind(this),
+        };
+        this.commands = {
+            datadog: {
+                commands: {
+                    clean: {
+                        lifecycleEvents: ["init"],
+                        usage: "Cleans up wrapper handler functions for DataDog, not necessary in most cases",
+                    },
+                    generate: {
+                        lifecycleEvents: ["init"],
+                        usage: "Generates wrapper handler functions for DataDog, not necessary in most cases",
+                    },
+                },
+                lifecycleEvents: ["clean", "generate"],
+                usage: "Automatically instruments your lambdas with DataDog",
+            },
+        };
+    }
+    beforePackageFunction() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.serverless.cli.log("Auto instrumenting functions with Datadog");
+            const config = env_1.getConfig(this.serverless.service);
+            env_1.setEnvConfiguration(config, this.serverless.service);
+            const defaultRuntime = this.serverless.service.provider.runtime;
+            const handlers = layer_1.findHandlers(this.serverless.service, defaultRuntime);
+            if (config.addLayers) {
+                this.serverless.cli.log("Adding Lambda Layers to functions");
+                this.debugLogHandlers(handlers);
+                layer_1.applyLayers(this.serverless.service.provider.region, handlers, layers);
+            }
+            else {
+                this.serverless.cli.log("Skipping adding Lambda Layers, make sure you are packaging them yourself");
+            }
+            let tracingMode = tracing_1.TracingMode.NONE;
+            if (config.enableXrayTracing && config.enableDDTracing) {
+                tracingMode = tracing_1.TracingMode.HYBRID;
+            }
+            else if (config.enableDDTracing) {
+                tracingMode = tracing_1.TracingMode.DD_TRACE;
+            }
+            else if (config.enableXrayTracing) {
+                tracingMode = tracing_1.TracingMode.XRAY;
+            }
+            tracing_1.enableTracing(this.serverless.service, tracingMode);
+        });
+    }
+    afterPackageFunction() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = env_1.getConfig(this.serverless.service);
+            if (config.forwarder) {
+                const aws = this.serverless.getProvider("aws");
+                const errors = yield forwarder_1.addCloudWatchForwarderSubscriptions(this.serverless.service, aws, config.forwarder);
+                for (const error of errors) {
+                    this.serverless.cli.log(error);
+                }
+            }
+            if (config.enableTags) {
+                this.serverless.cli.log("Adding service and environment tags to functions");
+                this.addServiceAndEnvTags();
+            }
+            const defaultRuntime = this.serverless.service.provider.runtime;
+            const handlers = layer_1.findHandlers(this.serverless.service, defaultRuntime);
+            wrapper_1.redirectHandlers(handlers, config.addLayers);
+        });
+    }
+    debugLogHandlers(handlers) {
+        for (const handler of handlers) {
+            if (handler.type === layer_1.RuntimeType.UNSUPPORTED) {
+                if (handler.runtime === undefined) {
+                    this.serverless.cli.log(`Unable to determine runtime for function ${handler.name}`);
+                }
+                else {
+                    this.serverless.cli.log(`Unable to add Lambda Layers to function ${handler.name} with runtime ${handler.runtime}`);
+                }
+            }
+        }
+    }
+    /**
+     * Check for service and env tags on provider level (under tags and stackTags),
+     * as well as function level. Automatically create tags for service and env with
+     * properties from deployment configurations if needed; does not override any existing values.
+     */
+    addServiceAndEnvTags() {
+        let providerServiceTagExists = false;
+        let providerEnvTagExists = false;
+        const provider = this.serverless.service.provider;
+        const providerTags = provider.tags;
+        if (providerTags !== undefined) {
+            providerServiceTagExists = providerTags[TagKeys.Service] !== undefined;
+            providerEnvTagExists = providerTags[TagKeys.Env] !== undefined;
+        }
+        const providerStackTags = provider.stackTags;
+        if (providerStackTags !== undefined) {
+            providerServiceTagExists = providerServiceTagExists || providerStackTags[TagKeys.Service] !== undefined;
+            providerEnvTagExists = providerEnvTagExists || providerStackTags[TagKeys.Env] !== undefined;
+        }
+        if (!providerServiceTagExists || !providerEnvTagExists) {
+            this.serverless.service.getAllFunctions().forEach((functionName) => {
+                const functionDefintion = this.serverless.service.getFunction(functionName);
+                if (!functionDefintion.tags) {
+                    functionDefintion.tags = {};
+                }
+                if (!providerServiceTagExists && !functionDefintion.tags[TagKeys.Service]) {
+                    functionDefintion.tags[TagKeys.Service] = this.serverless.service.getServiceName();
+                }
+                if (!providerEnvTagExists && !functionDefintion.tags[TagKeys.Env]) {
+                    functionDefintion.tags[TagKeys.Env] = this.serverless.getProvider("aws").getStage();
+                }
+            });
+        }
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;AAGH,sDAAwC;AAExC,+BAAuD;AACvD,mCAA+E;AAC/E,uCAAuD;AACvD,uCAA6C;AAC7C,2CAAkE;AASlE,IAAK,OAGJ;AAHD,WAAK,OAAO;IACV,8BAAmB,CAAA;IACnB,sBAAW,CAAA;AACb,CAAC,EAHI,OAAO,KAAP,OAAO,QAGX;AAED,MAAM,CAAC,OAAO,GAAG,MAAM,gBAAgB;IA4BrC,YAAoB,UAAsB,EAAE,CAAqB;QAA7C,eAAU,GAAV,UAAU,CAAY;QA3BnC,UAAK,GAAG;YACb,0BAA0B,EAAE,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC;YAChE,6BAA6B,EAAE,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC;YACpE,uCAAuC,EAAE,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC7E,yCAAyC,EAAE,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC/E,0BAA0B,EAAE,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC;YACjE,wCAAwC,EAAE,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC/E,2BAA2B,EAAE,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC;YAClE,qCAAqC,EAAE,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC;SAC7E,CAAC;QAEK,aAAQ,GAAG;YAChB,OAAO,EAAE;gBACP,QAAQ,EAAE;oBACR,KAAK,EAAE;wBACL,eAAe,EAAE,CAAC,MAAM,CAAC;wBACzB,KAAK,EAAE,8EAA8E;qBACtF;oBACD,QAAQ,EAAE;wBACR,eAAe,EAAE,CAAC,MAAM,CAAC;wBACzB,KAAK,EAAE,8EAA8E;qBACtF;iBACF;gBACD,eAAe,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC;gBACtC,KAAK,EAAE,qDAAqD;aAC7D;SACF,CAAC;IACkE,CAAC;IAEvD,qBAAqB;;YACjC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,2CAA2C,CAAC,CAAC;YACrE,MAAM,MAAM,GAAG,eAAS,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;YAClD,yBAAmB,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;YAErD,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;YAChE,MAAM,QAAQ,GAAG,oBAAY,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;YACvE,IAAI,MAAM,CAAC,SAAS,EAAE;gBACpB,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;gBAC7D,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;gBAChC,mBAAW,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;aACxE;iBAAM;gBACL,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,0EAA0E,CAAC,CAAC;aACrG;YAED,IAAI,WAAW,GAAG,qBAAW,CAAC,IAAI,CAAC;YACnC,IAAI,MAAM,CAAC,iBAAiB,IAAI,MAAM,CAAC,eAAe,EAAE;gBACtD,WAAW,GAAG,qBAAW,CAAC,MAAM,CAAC;aAClC;iBAAM,IAAI,MAAM,CAAC,eAAe,EAAE;gBACjC,WAAW,GAAG,qBAAW,CAAC,QAAQ,CAAC;aACpC;iBAAM,IAAI,MAAM,CAAC,iBAAiB,EAAE;gBACnC,WAAW,GAAG,qBAAW,CAAC,IAAI,CAAC;aAChC;YACD,uBAAa,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QACtD,CAAC;KAAA;IACa,oBAAoB;;YAChC,MAAM,MAAM,GAAG,eAAS,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;YAClD,IAAI,MAAM,CAAC,SAAS,EAAE;gBACpB,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;gBAC/C,MAAM,MAAM,GAAG,MAAM,+CAAmC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,GAAG,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC;gBACzG,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE;oBAC1B,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;iBAChC;aACF;YAED,IAAI,MAAM,CAAC,UAAU,EAAE;gBACrB,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,kDAAkD,CAAC,CAAC;gBAC5E,IAAI,CAAC,oBAAoB,EAAE,CAAC;aAC7B;YAED,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;YAChE,MAAM,QAAQ,GAAG,oBAAY,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;YACvE,0BAAgB,CAAC,QAAQ,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC;QAC/C,CAAC;KAAA;IAEO,gBAAgB,CAAC,QAAwB;QAC/C,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;YAC9B,IAAI,OAAO,CAAC,IAAI,KAAK,mBAAW,CAAC,WAAW,EAAE;gBAC5C,IAAI,OAAO,CAAC,OAAO,KAAK,SAAS,EAAE;oBACjC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,4CAA4C,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;iBACrF;qBAAM;oBACL,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CACrB,2CAA2C,OAAO,CAAC,IAAI,iBAAiB,OAAO,CAAC,OAAO,EAAE,CAC1F,CAAC;iBACH;aACF;SACF;IACH,CAAC;IAED;;;;OAIG;IACK,oBAAoB;QAC1B,IAAI,wBAAwB,GAAG,KAAK,CAAC;QACrC,IAAI,oBAAoB,GAAG,KAAK,CAAC;QAEjC,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,QAAe,CAAC;QAEzD,MAAM,YAAY,GAAG,QAAQ,CAAC,IAAI,CAAC;QACnC,IAAI,YAAY,KAAK,SAAS,EAAE;YAC9B,wBAAwB,GAAG,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,SAAS,CAAC;YACvE,oBAAoB,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC;SAChE;QAED,MAAM,iBAAiB,GAAG,QAAQ,CAAC,SAAS,CAAC;QAC7C,IAAI,iBAAiB,KAAK,SAAS,EAAE;YACnC,wBAAwB,GAAG,wBAAwB,IAAI,iBAAiB,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,SAAS,CAAC;YACxG,oBAAoB,GAAG,oBAAoB,IAAI,iBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC;SAC7F;QAED,IAAI,CAAC,wBAAwB,IAAI,CAAC,oBAAoB,EAAE;YACtD,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC,OAAO,CAAC,CAAC,YAAY,EAAE,EAAE;gBACjE,MAAM,iBAAiB,GAA+B,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;gBACxG,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE;oBAC3B,iBAAiB,CAAC,IAAI,GAAG,EAAE,CAAC;iBAC7B;gBACD,IAAI,CAAC,wBAAwB,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;oBACzE,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;iBACpF;gBACD,IAAI,CAAC,oBAAoB,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;oBACjE,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC;iBACrF;YACH,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;CACF,CAAC"}