pax_global_header00006660000000000000000000000064136635520310014516gustar00rootroot0000000000000052 comment=2f667eab58eb3c596542116f56cfd99e21b86bf5 datadog-lambda-python-18/000077500000000000000000000000001366355203100154505ustar00rootroot00000000000000datadog-lambda-python-18/.circleci/000077500000000000000000000000001366355203100173035ustar00rootroot00000000000000datadog-lambda-python-18/.circleci/config.yml000066400000000000000000000027301366355203100212750ustar00rootroot00000000000000version: 2.1 jobs: verify_build: working_directory: ~/repo docker: - image: circleci/python:<< parameters.python >> parameters: python: type: string steps: - checkout - restore_cache: keys: - v1-dependencies-<< parameters.python >>-{{ checksum "setup.py" }} # fallback to using the latest cache if no exact match is found - v1-dependencies-<< parameters.python >>-- - run: name: Install Dependencies command: | pip install virtualenv virtualenv venv source venv/bin/activate pip install .[dev] - run: name: Run Unit Tests command: | source venv/bin/activate nose2 -v - run: name: Lint command: | source venv/bin/activate flake8 datadog_lambda/ - run: name: Check Formatting command: | source venv/bin/activate ./scripts/check_format.sh - save_cache: paths: - ./venv key: v1-dependencies-<< parameters.python >>-{{ checksum "setup.py" }} workflows: python-v2.7: jobs: - verify_build: python: "2.7" python-v3.6: jobs: - verify_build: python: "3.6" python-v3.7: jobs: - verify_build: python: "3.7" python-v3.8: jobs: - verify_build: python: "3.8" datadog-lambda-python-18/.flake8000066400000000000000000000000361366355203100166220ustar00rootroot00000000000000[flake8] max-line-length = 100datadog-lambda-python-18/.github/000077500000000000000000000000001366355203100170105ustar00rootroot00000000000000datadog-lambda-python-18/.github/ISSUE_TEMPLATE/000077500000000000000000000000001366355203100211735ustar00rootroot00000000000000datadog-lambda-python-18/.github/ISSUE_TEMPLATE/bug_report_template.md000066400000000000000000000004321366355203100255570ustar00rootroot00000000000000--- name: Bug Report about: Create a report to help us improve --- ## Expected Behavior ## Actual Behavior ## Steps to Reproduce the Problem 1. 1. 1. ## Specifications - Datadog Lambda Layer version: - Python version: ## Stacktrace ``` Paste here ```datadog-lambda-python-18/.github/ISSUE_TEMPLATE/feature_request_template.md000066400000000000000000000004141366355203100266120ustar00rootroot00000000000000--- name: Feature Request about: Suggest an idea --- ## Expected Behavior ## Actual Behavior ## Steps to Reproduce the Problem 1. 1. 1. ## Specifications - Datadog Lambda Layer version: - Python version: ## Stacktrace ``` Paste here ```datadog-lambda-python-18/.github/pull_request_template.md000066400000000000000000000011011366355203100237420ustar00rootroot00000000000000_Note: Please remember to review the [contribution guidelines](https://github.com/DataDog/datadog-lambda-layer-python/blob/master/CONTRIBUTING.md) if you have not yet done so._ ### What does this PR do? A brief description of the change being made with this pull request. ### Motivation What inspired you to submit this pull request? ### Testing Guidelines How did you test this pull request? ### Additional Notes Anything else we should know when reviewing? ### Checklist - [ ] Member of the Datadog team has run integration tests and updated snapshots if necessary datadog-lambda-python-18/.gitignore000066400000000000000000000005011366355203100174340ustar00rootroot00000000000000*.py[cod] # Layer zips .layers # C extensions *.so # Packages *.egg *.egg-info dist build eggs parts bin var sdist develop-eggs .installed.cfg lib lib64 __pycache__ # Installer logs pip-log.txt # Unit test / coverage reports .coverage .tox nosetests.xml #Misc .cache/ .DS_Store .eggs/ .env/ .idea/ **/.serverless/datadog-lambda-python-18/CODEOWNERS000066400000000000000000000000251366355203100170400ustar00rootroot00000000000000* @DataDog/serverlessdatadog-lambda-python-18/CONTRIBUTING.md000066400000000000000000000010351366355203100177000ustar00rootroot00000000000000# Contributing We love pull requests. Here's a quick guide. Fork, then clone: ```bash git clone git@github.com:your-username/datadog-lambda-layer-python.git ``` Make your change, update tests and ensure the tests pass (install Docker if you haven't): ```bash ./scripts/run_tests.sh ``` Push to your fork and [submit a pull request][pr]. [pr]: https://github.com/your-username/datadog-lambda-layer-python/compare/DataDog:master...master At this point you're waiting on us. We may suggest some changes or improvements or alternatives. datadog-lambda-python-18/Dockerfile000066400000000000000000000010611366355203100174400ustar00rootroot00000000000000ARG image FROM $image ARG runtime # Create the directory structure required for AWS Lambda Layer RUN mkdir -p /build/python/lib/$runtime/site-packages WORKDIR /build # Install datadog_lambda and dependencies from local COPY . . RUN pip install . -t ./python/lib/$runtime/site-packages # Remove *.pyc files RUN find ./python/lib/$runtime/site-packages -name \*.pyc -delete # Remove botocore (40MB) to reduce package size. aws-xray-sdk # installs it, while it's already provided by the Lambda Runtime. RUN rm -rf ./python/lib/$runtime/site-packages/botocore*datadog-lambda-python-18/LICENSE000066400000000000000000000261631366355203100164650ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright 2018 Datadog, Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. SPDX-License-Identifier: Apache-2.0datadog-lambda-python-18/LICENSE-3rdparty.csv000066400000000000000000000010411366355203100210110ustar00rootroot00000000000000Component,Origin,License,Copyright aws-xray-sdk-python,github.com/aws/aws-xray-sdk-python,Apache-2.0, flake8,gitlab.com/pycqa/flake8,MIT,"Copyright (C) 2011-2013 Tarek Ziade . Copyright (C) 2012-2016 Ian Cordasco ." nose2,github.com/nose-devs/nose2,BSD-2-Clause,"Copyright (c) 2012, Jason Pellerin. All rights reserved." requests,github.com/kennethreitz/requests,Apache-2.0,"Copyright 2018 Kenneth Reitz" wrapt,github.com/GrahamDumpleton/wrapt,BSD-2-Clause,"Copyright (c) 2013-2019, Graham Dumpleton"datadog-lambda-python-18/NOTICE000066400000000000000000000002231366355203100163510ustar00rootroot00000000000000Datadog datadog-lambda-layer-python Copyright 2019 Datadog, Inc. This product includes software developed at Datadog (https://www.datadoghq.com/).datadog-lambda-python-18/README.md000066400000000000000000000343541366355203100167400ustar00rootroot00000000000000# datadog-lambda-layer-python [![CircleCI](https://img.shields.io/circleci/build/github/DataDog/datadog-lambda-layer-python)](https://circleci.com/gh/DataDog/datadog-lambda-layer-python) [![PyPI](https://img.shields.io/pypi/v/datadog-lambda)](https://pypi.org/project/datadog-lambda/) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/datadog-lambda) [![Slack](https://img.shields.io/badge/slack-%23serverless-blueviolet?logo=slack)](https://datadoghq.slack.com/channels/serverless/) [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](https://github.com/DataDog/datadog-lambda-layer-python/blob/master/LICENSE) Datadog Lambda Layer for Python (2.7, 3.6, 3.7 and 3.8) enables custom metric submission from AWS Lambda functions, and distributed tracing between serverful and serverless environments. ## IMPORTANT NOTE AWS Lambda is expected to recieve a [breaking change](https://aws.amazon.com/blogs/compute/upcoming-changes-to-the-python-sdk-in-aws-lambda/) on **January 30, 2021**. If you are using Datadog Python Lambda layer version 7 or below, please upgrade to version 11. ## Installation Datadog Lambda Layer can be added to a Lambda function via AWS Lambda console, [AWS CLI](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html#configuration-layers-using) or [Serverless Framework](https://serverless.com/framework/docs/providers/aws/guide/layers/#using-your-layers) using the following ARN. ``` arn:aws:lambda::464622532012:layer:Datadog-: ``` Replace `` with the AWS region where your Lambda function is published to. Replace `` with one of the following that matches your Lambda's Python runtime: - `Datadog-Python27` - `Datadog-Python36` - `Datadog-Python37` - `Datadog-Python38` Replace `` with the latest layer version that can be found from [releases](https://github.com/DataDog/datadog-lambda-layer-python/releases). For example, ``` arn:aws:lambda:us-east-1:464622532012:layer:Datadog-Python37:1 ``` ### PyPI When developing your Lambda function locally where AWS Layer doesn't work, the Datadog Lambda layer can be installed from [PyPI](https://pypi.org/project/datadog-lambda/) by `pip install datadog-lambda` or adding `datadog-lambda` to your project's `requirements.txt`. The minor version of the `datadog-lambda` package always match the layer version. E.g., datadog-lambda v0.5.0 matches the content in layer version 5. ### The Serverless Framework [The Datadog Serverless Framework Plugin](https://github.com/DataDog/serverless-plugin-datadog) makes it easy to manage the Datadog instrumentation for all of your Lambda functions in one place. Instead of the plugin, you can also use the sample `serverless.yml` below as a reference for manually including the Lambda Layer, enable AWS X-Ray tracing, and set up environment variables. ```yaml provider: name: aws runtime: python3.7 tracing: lambda: true apiGateway: true functions: hello: handler: handler.hello events: - http: path: hello method: get layers: - arn:aws:lambda::464622532012:layer:Datadog-: environment: DD_FLUSH_TO_LOG: true ``` Alternatively, consider using [serverless-plugin-datadog](https://github.com/DataDog/serverless-plugin-datadog). The plugin can take care of adding lambda layers to your functions, and wrapping your handlers. ## Environment Variables ### DD_FLUSH_TO_LOG Set to `true` (recommended) to send custom metrics asynchronously (with no added latency to your Lambda function executions) through CloudWatch Logs with the help of [Datadog Forwarder](https://github.com/DataDog/datadog-serverless-functions/tree/master/aws/logs_monitoring). If set to `false`, you also need to set `DD_API_KEY` and `DD_SITE`. ### DD_API_KEY If `DD_FLUSH_TO_LOG` is set to false (not recommended), the Datadog API Key must be defined as one of the following environment variables: - DD_API_KEY - the Datadog API Key in plain-text, NOT recommended - DD_KMS_API_KEY - the KMS-encrypted API Key, requires the `kms:Decrypt` permission - DD_API_KEY_SECRET_ARN - the Secret ARN to fetch API Key from the Secrets Manager, requires the `secretsmanager:GetSecretValue` permission (and `kms:Decrypt` if using a customer managed CMK) You can also supply or override the API key at runtime (not recommended): ```python # Override DD API Key after importing datadog_lambda packages from datadog import api api._api_key = "MY_API_KEY" ``` ### DD_SITE If `DD_FLUSH_TO_LOG` is set to false (not recommended), and your data need to be sent to the Datadog EU site, you must set `DD_SITE` to `datadoghq.eu`. ### DD_LOGS_INJECTION Inject Datadog trace id into logs for [correlation](https://docs.datadoghq.com/tracing/connect_logs_and_traces/?tab=python). Defaults to true. ### DD_LOG_LEVEL Set to `debug` enable debug los from the Datadog Lambda Layer. ### DD_ENHANCED_METRICS Generate enhanced Datadog Lambda integration metrics, such as, `aws.lambda.enhanced.invocations` and `aws.lambda.enhanced.errors`. Defaults to true. ### DD_LAMBDA_HANDLER For use with the [redirected handler](#Redirected-Handler) method. Location of your original lambda handler. ### DD_TRACE_ENABLED When used with the [redirected handler](#Redirected-Handler) method, will auto initialize the tracer when set to true. ## Basic Usage Datadog needs to be able to read headers from the incoming Lambda event. To do this, you must wrap your handler function with our library. We provide some easy ways of wrapping your handlers. ### Redirected Handler We provide a swap in replacement handler, with zero required code changes. 1. Set the environment variable `DD_LAMBDA_HANDLER` to your regular handler location, eg. `myfunc.handler`. 2. Set your handler to `datadog_lambda.handler.handler`. ### Manual Wrap You might find it more convenient to wrap your handlers manually. ```python import requests from datadog_lambda.wrapper import datadog_lambda_wrapper from datadog_lambda.metric import lambda_metric @datadog_lambda_wrapper def lambda_handler(event, context): lambda_metric("my_metric", 10, tags=['tag:value']) requests.get("https://www.datadoghq.com") ``` ## Custom Metrics Custom metrics can be submitted using `lambda_metric` and the Lambda handler function needs to be decorated with `@datadog_lambda_wrapper`. The metrics are submitted as [distribution metrics](https://docs.datadoghq.com/graphing/metrics/distributions/). **IMPORTANT NOTE:** If you have already been submitting the same custom metric as non-distribution metric (e.g., gauge, count, or histogram) without using the Datadog Lambda Layer, you MUST pick a new metric name to use for `lambda_metric`. Otherwise that existing metric will be converted to a distribution metric and the historical data prior to the conversion will be no longer queryable. ```python from datadog_lambda.wrapper import datadog_lambda_wrapper from datadog_lambda.metric import lambda_metric @datadog_lambda_wrapper def lambda_handler(event, context): lambda_metric( "coffee_house.order_value", # metric 12.45, # value tags=['product:latte', 'order:online'] # tags ) ``` ### VPC If your Lambda function is associated with a VPC, you need to ensure it has [access to the public internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/). ## Distributed Tracing [Distributed tracing](https://docs.datadoghq.com/tracing/guide/distributed_tracing/?tab=python) allows you to propagate a trace context from a service running on a host to a service running on AWS Lambda, and vice versa, so you can see performance end-to-end. Linking is implemented by injecting Datadog trace context into the HTTP request headers. Distributed tracing headers are language agnostic, e.g., a trace can be propagated between a Java service running on a host to a Lambda function written in Python. Because the trace context is propagated through HTTP request headers, the Lambda function needs to be triggered by AWS API Gateway or AWS Application Load Balancer. To enable this feature, you simple need to decorate your Lambda handler function with `@datadog_lambda_wrapper`. ```python import requests from datadog_lambda.wrapper import datadog_lambda_wrapper @datadog_lambda_wrapper def lambda_handler(event, context): requests.get("https://www.datadoghq.com") ``` Note, the Datadog Lambda Layer is only needed to enable _distributed_ tracing between Lambda and non-Lambda services. For standalone Lambda functions, traces can be found in Datadog APM after configuring [the X-Ray integration](https://docs.datadoghq.com/integrations/amazon_xray/). ### Patching By default, widely used HTTP client libraries, such as `requests`, `urllib2` and `urllib.request` are patched automatically to inject Datadog trace context into outgoing requests. You can also manually retrieve the Datadog trace context (i.e., http headers in a Python dict) and inject it to request headers when needed. ```python import requests from datadog_lambda.wrapper import datadog_lambda_wrapper from datadog_lambda.tracing import get_dd_trace_context @datadog_lambda_wrapper def lambda_handler(event, context): headers = get_dd_trace_context() requests.get("https://www.datadoghq.com", headers=headers) ``` ### Sampling The traces for your Lambda function are converted by Datadog from AWS X-Ray traces. X-Ray needs to sample the traces that the Datadog tracing agent decides to sample, in order to collect as many complete traces as possible. You can create X-Ray sampling rules to ensure requests with header `x-datadog-sampling-priority:1` or `x-datadog-sampling-priority:2` via API Gateway always get sampled by X-Ray. These rules can be created using the following AWS CLI command. ```bash aws xray create-sampling-rule --cli-input-json file://datadog-sampling-priority-1.json aws xray create-sampling-rule --cli-input-json file://datadog-sampling-priority-2.json ``` The file content for `datadog-sampling-priority-1.json`: ```json { "SamplingRule": { "RuleName": "Datadog-Sampling-Priority-1", "ResourceARN": "*", "Priority": 9998, "FixedRate": 1, "ReservoirSize": 100, "ServiceName": "*", "ServiceType": "AWS::APIGateway::Stage", "Host": "*", "HTTPMethod": "*", "URLPath": "*", "Version": 1, "Attributes": { "x-datadog-sampling-priority": "1" } } } ``` The file content for `datadog-sampling-priority-2.json`: ```json { "SamplingRule": { "RuleName": "Datadog-Sampling-Priority-2", "ResourceARN": "*", "Priority": 9999, "FixedRate": 1, "ReservoirSize": 100, "ServiceName": "*", "ServiceType": "AWS::APIGateway::Stage", "Host": "*", "HTTPMethod": "*", "URLPath": "*", "Version": 1, "Attributes": { "x-datadog-sampling-priority": "2" } } } ``` ### Non-proxy integration If your Lambda function is triggered by API Gateway via [the non-proxy integration](https://docs.aws.amazon.com/apigateway/latest/developerguide/getting-started-lambda-non-proxy-integration.html), then you have to [set up a mapping template](https://aws.amazon.com/premiumsupport/knowledge-center/custom-headers-api-gateway-lambda/), which passes the Datadog trace context from the incoming HTTP request headers to the Lambda function via the `event` object. If your Lambda function is deployed by the Serverless Framework, such a mapping template gets created by default. ## Log and Trace Correlations By default, the Datadog trace id gets automatically injected into the logs for correlation, if using the standard python `logging` library. If you use a custom logger handler to log in json, you can inject the ids using the helper function `get_correlation_ids` [manually](https://docs.datadoghq.com/tracing/connect_logs_and_traces/?tab=python#manual-trace-id-injection). Set the environment variable `DD_LOGS_INJECTION` to `false` to disable this feature. ```python from datadog_lambda.wrapper import datadog_lambda_wrapper from ddtrace.helpers import get_correlation_ids @datadog_lambda_wrapper def lambda_handler(event, context): trace_id, span_id = get_correlation_ids() logger.info({ "message": "hello world", "dd": { "trace_id": trace_id, "span_id": span_id } }) ``` ## Datadog Tracer (**Beta**) You can now trace Lambda functions using Datadog APM's tracing libraries ([dd-trace-py](https://github.com/DataDog/dd-trace-py)). 1. If you are using the Lambda layer, upgrade it to at least version 15. 1. If you are using the pip package `datadog-lambda-python`, upgrade it to at least version `v2.15.0`. 1. Install (or update to) the latest version of [Datadog forwarder Lambda function](https://docs.datadoghq.com/integrations/amazon_web_services/?tab=allpermissions#set-up-the-datadog-lambda-function). Ensure the trace forwarding layer is attached to the forwarder, e.g., ARN for Python 2.7 `arn:aws:lambda::464622532012:layer:Datadog-Trace-Forwarder-Python27:4`. 1. Set the environment variable `DD_TRACE_ENABLED` to true on your function. 1. Instrument your function using `dd-trace`. ```py from datadog_lambda.metric import lambda_metric from datadog_lambda.wrapper import datadog_lambda_wrapper from ddtrace import tracer @datadog_lambda_wrapper def hello(event, context): return { "statusCode": 200, "body": get_message() } @tracer.wrap() def get_message(): return "hello world" ``` You can also use `dd-trace` and the X-Ray tracer together and merge the traces into one, using the environment variable `DD_MERGE_XRAY_TRACES` to true on your function. ## Opening Issues If you encounter a bug with this package, we want to hear about it. Before opening a new issue, search the existing issues to avoid duplicates. When opening an issue, include the Datadog Lambda Layer version, Python version, and stack trace if available. In addition, include the steps to reproduce when appropriate. You can also open an issue for a feature request. ## Contributing If you find an issue with this package and have a fix, please feel free to open a pull request following the [procedures](CONTRIBUTING.md). ## License 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. datadog-lambda-python-18/datadog_lambda/000077500000000000000000000000001366355203100203535ustar00rootroot00000000000000datadog-lambda-python-18/datadog_lambda/__init__.py000066400000000000000000000004461366355203100224700ustar00rootroot00000000000000# The minor version corresponds to the Lambda layer version. # E.g.,, version 0.5.0 gets packaged into layer version 5. __version__ = "2.18.0" import os import logging logger = logging.getLogger(__name__) logger.setLevel(logging.getLevelName(os.environ.get("DD_LOG_LEVEL", "INFO").upper())) datadog-lambda-python-18/datadog_lambda/cold_start.py000066400000000000000000000011641366355203100230650ustar00rootroot00000000000000_cold_start = True _lambda_container_initialized = False def set_cold_start(): """Set the value of the cold start global This should be executed once per Lambda execution before the execution """ global _cold_start global _lambda_container_initialized _cold_start = not _lambda_container_initialized _lambda_container_initialized = True def is_cold_start(): """Returns the value of the global cold_start """ return _cold_start def get_cold_start_tag(): """Returns the cold start tag to be used in metrics """ return "cold_start:{}".format(str(is_cold_start()).lower()) datadog-lambda-python-18/datadog_lambda/constants.py000066400000000000000000000016721366355203100227470ustar00rootroot00000000000000# 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. # Datadog trace sampling priority class SamplingPriority(object): USER_REJECT = -1 AUTO_REJECT = 0 AUTO_KEEP = 1 USER_KEEP = 2 # Datadog trace headers class TraceHeader(object): TRACE_ID = "x-datadog-trace-id" PARENT_ID = "x-datadog-parent-id" SAMPLING_PRIORITY = "x-datadog-sampling-priority" # X-Ray subsegment to save Datadog trace metadata class XraySubsegment(object): NAME = "datadog-metadata" KEY = "trace" NAMESPACE = "datadog" # TraceContextSource of datadog context. The DD_MERGE_XRAY_TRACES # feature uses this to determine when to use X-Ray as the parent # trace. class TraceContextSource(object): XRAY = "xray" EVENT = "event" DDTRACE = "ddtrace" datadog-lambda-python-18/datadog_lambda/handler.py000066400000000000000000000015551366355203100223500ustar00rootroot00000000000000# 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 2020 Datadog, Inc. from __future__ import absolute_import from importlib import import_module import os from datadog_lambda.wrapper import datadog_lambda_wrapper class HandlerError(Exception): pass path = os.environ.get("DD_LAMBDA_HANDLER", None) if path is None: raise HandlerError( "DD_LAMBDA_HANDLER is not defined. Can't use prebuilt datadog handler" ) parts = path.rsplit(".", 1) if len(parts) != 2: raise HandlerError("Value %s for DD_LAMBDA_HANDLER has invalid format." % path) (mod_name, handler_name) = parts handler_module = import_module(mod_name) handler = datadog_lambda_wrapper(getattr(handler_module, handler_name)) datadog-lambda-python-18/datadog_lambda/metric.py000066400000000000000000000107551366355203100222200ustar00rootroot00000000000000# 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. import os import json import time import base64 import logging import boto3 from datadog import api from datadog.threadstats import ThreadStats from datadog_lambda.tags import get_enhanced_metrics_tags, tag_dd_lambda_layer ENHANCED_METRICS_NAMESPACE_PREFIX = "aws.lambda.enhanced" logger = logging.getLogger(__name__) lambda_stats = ThreadStats() lambda_stats.start() def lambda_metric(metric_name, value, timestamp=None, tags=None): """ Submit a data point to Datadog distribution metrics. https://docs.datadoghq.com/graphing/metrics/distributions/ When DD_FLUSH_TO_LOG is True, write metric to log, and wait for the Datadog Log Forwarder Lambda function to submit the metrics asynchronously. Otherwise, the metrics will be submitted to the Datadog API periodically and at the end of the function execution in a background thread. """ tags = tag_dd_lambda_layer(tags) if os.environ.get("DD_FLUSH_TO_LOG", "").lower() == "true": write_metric_point_to_stdout(metric_name, value, timestamp, tags) else: logger.debug("Sending metric %s to Datadog via lambda layer", metric_name) lambda_stats.distribution(metric_name, value, timestamp=timestamp, tags=tags) def write_metric_point_to_stdout(metric_name, value, timestamp=None, tags=[]): """Writes the specified metric point to standard output """ logger.debug( "Sending metric %s value %s to Datadog via log forwarder", metric_name, value ) print( json.dumps( { "m": metric_name, "v": value, "e": timestamp or int(time.time()), "t": tags, } ) ) def are_enhanced_metrics_enabled(): """Check env var to find if enhanced metrics should be submitted Returns: boolean for whether enhanced metrics are enabled """ # DD_ENHANCED_METRICS defaults to true return os.environ.get("DD_ENHANCED_METRICS", "true").lower() == "true" def submit_enhanced_metric(metric_name, lambda_context): """Submits the enhanced metric with the given name Args: metric_name (str): metric name w/o enhanced prefix i.e. "invocations" or "errors" lambda_context (dict): Lambda context dict passed to the function by AWS """ if not are_enhanced_metrics_enabled(): logger.debug( "Not submitting enhanced metric %s because enhanced metrics are disabled", metric_name, ) return # Enhanced metrics are always written to logs write_metric_point_to_stdout( "{}.{}".format(ENHANCED_METRICS_NAMESPACE_PREFIX, metric_name), 1, tags=get_enhanced_metrics_tags(lambda_context), ) def submit_invocations_metric(lambda_context): """Increment aws.lambda.enhanced.invocations by 1, applying runtime, layer, and cold_start tags Args: lambda_context (dict): Lambda context dict passed to the function by AWS """ submit_enhanced_metric("invocations", lambda_context) def submit_errors_metric(lambda_context): """Increment aws.lambda.enhanced.errors by 1, applying runtime, layer, and cold_start tags Args: lambda_context (dict): Lambda context dict passed to the function by AWS """ submit_enhanced_metric("errors", lambda_context) # Set API Key and Host in the module, so they only set once per container if not api._api_key: DD_API_KEY_SECRET_ARN = os.environ.get("DD_API_KEY_SECRET_ARN", "") DD_KMS_API_KEY = os.environ.get("DD_KMS_API_KEY", "") DD_API_KEY = os.environ.get("DD_API_KEY", os.environ.get("DATADOG_API_KEY", "")) if DD_API_KEY_SECRET_ARN: api._api_key = boto3.client("secretsmanager").get_secret_value( SecretId=DD_API_KEY_SECRET_ARN )["SecretString"] elif DD_KMS_API_KEY: api._api_key = boto3.client("kms").decrypt( CiphertextBlob=base64.b64decode(DD_KMS_API_KEY) )["Plaintext"] else: api._api_key = DD_API_KEY logger.debug("Setting DATADOG_API_KEY of length %d", len(api._api_key)) # Set DATADOG_HOST, to send data to a non-default Datadog datacenter api._api_host = os.environ.get( "DATADOG_HOST", "https://api." + os.environ.get("DD_SITE", "datadoghq.com") ) logger.debug("Setting DATADOG_HOST to %s", api._api_host) datadog-lambda-python-18/datadog_lambda/patch.py000066400000000000000000000111211366355203100220200ustar00rootroot00000000000000# 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. import json import os import sys import logging from wrapt import wrap_function_wrapper as wrap from wrapt.importer import when_imported from ddtrace import patch_all as patch_all_dd from datadog_lambda.tracing import ( get_dd_trace_context, dd_tracing_enabled, ) logger = logging.getLogger(__name__) if sys.version_info >= (3, 0, 0): httplib_module = "http.client" from collections.abc import MutableMapping else: httplib_module = "httplib" from collections import MutableMapping _httplib_patched = False _requests_patched = False _integration_tests_patched = False def patch_all(): """ Patch third-party libraries for tracing. """ _patch_for_integration_tests() if dd_tracing_enabled: patch_all_dd() else: _patch_httplib() _ensure_patch_requests() def _patch_for_integration_tests(): """ Patch `requests` to log the outgoing requests for integration tests. """ global _integration_tests_patched is_in_tests = os.environ.get("DD_INTEGRATION_TEST", "false").lower() == "true" if not _integration_tests_patched and is_in_tests: wrap("requests", "Session.send", _log_request) _integration_tests_patched = True def _patch_httplib(): """ Patch the Python built-in `httplib` (Python 2) or `http.client` (Python 3) module. """ global _httplib_patched if not _httplib_patched: _httplib_patched = True wrap(httplib_module, "HTTPConnection.request", _wrap_httplib_request) logger.debug("Patched %s", httplib_module) def _ensure_patch_requests(): """ `requests` is third-party, may not be installed or used, but ensure it gets patched if installed and used. """ if "requests" in sys.modules: # already imported, patch now _patch_requests(sys.modules["requests"]) else: # patch when imported when_imported("requests")(_patch_requests) def _patch_requests(module): """ Patch the high-level HTTP client module `requests` if it's installed. """ global _requests_patched if not _requests_patched: _requests_patched = True try: wrap("requests", "Session.request", _wrap_requests_request) logger.debug("Patched requests") except Exception: logger.debug("Failed to patch requests", exc_info=True) def _wrap_requests_request(func, instance, args, kwargs): """ Wrap `requests.Session.request` to inject the Datadog trace headers into the outgoing requests. """ context = get_dd_trace_context() if "headers" in kwargs and isinstance(kwargs["headers"], MutableMapping): kwargs["headers"].update(context) elif len(args) >= 5 and isinstance(args[4], MutableMapping): args[4].update(context) else: kwargs["headers"] = context return func(*args, **kwargs) def _wrap_httplib_request(func, instance, args, kwargs): """ Wrap `httplib` (python2) or `http.client` (python3) to inject the Datadog trace headers into the outgoing requests. """ context = get_dd_trace_context() if "headers" in kwargs and isinstance(kwargs["headers"], MutableMapping): kwargs["headers"].update(context) elif len(args) >= 4 and isinstance(args[3], MutableMapping): args[3].update(context) else: kwargs["headers"] = context return func(*args, **kwargs) def _log_request(func, instance, args, kwargs): request = kwargs.get("request") or args[0] _print_request_string(request) return func(*args, **kwargs) def _print_request_string(request): """Print the request so that it can be checked in integration tests Only used by integration tests. """ method = request.method url = request.url # Sort the datapoints POSTed by their name so that snapshots always align data = request.body or "{}" data_dict = json.loads(data) data_dict.get("series", []).sort(key=lambda series: series.get("metric")) sorted_data = json.dumps(data_dict) # Sort headers to prevent any differences in ordering headers = request.headers or {} sorted_headers = sorted( "{}:{}".format(key, value) for key, value in headers.items() ) sorted_header_str = json.dumps(sorted_headers) print( "HTTP {} {} Headers: {} Data: {}".format( method, url, sorted_header_str, sorted_data ) ) datadog-lambda-python-18/datadog_lambda/tags.py000066400000000000000000000036661366355203100216760ustar00rootroot00000000000000import sys from platform import python_version_tuple from datadog_lambda import __version__ from datadog_lambda.cold_start import get_cold_start_tag def _format_dd_lambda_layer_tag(): """ Formats the dd_lambda_layer tag, e.g., 'dd_lambda_layer:datadog-python27_1' """ runtime = "python{}{}".format(sys.version_info[0], sys.version_info[1]) return "dd_lambda_layer:datadog-{}_{}".format(runtime, __version__) def tag_dd_lambda_layer(tags): """ Used by lambda_metric to insert the dd_lambda_layer tag """ dd_lambda_layer_tag = _format_dd_lambda_layer_tag() if tags: return tags + [dd_lambda_layer_tag] else: return [dd_lambda_layer_tag] def parse_lambda_tags_from_arn(arn): """Generate the list of lambda tags based on the data in the arn Args: arn (str): Lambda ARN. ex: arn:aws:lambda:us-east-1:123597598159:function:my-lambda[:optional-version] """ # Cap the number of times to split split_arn = arn.split(":") # If ARN includes version / alias at the end, drop it if len(split_arn) > 7: split_arn = split_arn[:7] _, _, _, region, account_id, _, function_name = split_arn return [ "region:{}".format(region), "account_id:{}".format(account_id), "functionname:{}".format(function_name), ] def get_runtime_tag(): """Get the runtime tag from the current Python version """ major_version, minor_version, _ = python_version_tuple() return "runtime:python{major}.{minor}".format( major=major_version, minor=minor_version ) def get_enhanced_metrics_tags(lambda_context): """Get the list of tags to apply to enhanced metrics """ return parse_lambda_tags_from_arn(lambda_context.invoked_function_arn) + [ get_cold_start_tag(), "memorysize:{}".format(lambda_context.memory_limit_in_mb), get_runtime_tag(), _format_dd_lambda_layer_tag(), ] datadog-lambda-python-18/datadog_lambda/tracing.py000066400000000000000000000210321366355203100223520ustar00rootroot00000000000000# 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. import logging import os from aws_xray_sdk.core import xray_recorder from aws_xray_sdk.core.lambda_launcher import LambdaContext from datadog_lambda.constants import ( SamplingPriority, TraceHeader, XraySubsegment, TraceContextSource, ) from ddtrace import tracer, patch from ddtrace.propagation.http import HTTPPropagator logger = logging.getLogger(__name__) dd_trace_context = {} dd_tracing_enabled = os.environ.get("DD_TRACE_ENABLED", "false").lower() == "true" propagator = HTTPPropagator() def _convert_xray_trace_id(xray_trace_id): """ Convert X-Ray trace id (hex)'s last 63 bits to a Datadog trace id (int). """ return str(0x7FFFFFFFFFFFFFFF & int(xray_trace_id[-16:], 16)) def _convert_xray_entity_id(xray_entity_id): """ Convert X-Ray (sub)segement id (hex) to a Datadog span id (int). """ return str(int(xray_entity_id, 16)) def _convert_xray_sampling(xray_sampled): """ Convert X-Ray sampled (True/False) to its Datadog counterpart. """ return ( str(SamplingPriority.USER_KEEP) if xray_sampled else str(SamplingPriority.USER_REJECT) ) def _get_xray_trace_context(): if not is_lambda_context(): return None xray_trace_entity = xray_recorder.get_trace_entity() # xray (sub)segment return { "trace-id": _convert_xray_trace_id(xray_trace_entity.trace_id), "parent-id": _convert_xray_entity_id(xray_trace_entity.id), "sampling-priority": _convert_xray_sampling(xray_trace_entity.sampled), "source": TraceContextSource.XRAY, } def _get_dd_trace_py_context(): span = tracer.current_span() if not span: return None parent_id = span.context.span_id trace_id = span.context.trace_id sampling_priority = span.context.sampling_priority return { "parent-id": str(parent_id), "trace-id": str(trace_id), "sampling-priority": str(sampling_priority), "source": TraceContextSource.DDTRACE, } def _context_obj_to_headers(obj): return { TraceHeader.TRACE_ID: str(obj.get("trace-id")), TraceHeader.PARENT_ID: str(obj.get("parent-id")), TraceHeader.SAMPLING_PRIORITY: str(obj.get("sampling-priority")), } def extract_dd_trace_context(event): """ Extract Datadog trace context from the Lambda `event` object. Write the context to a global `dd_trace_context`, so the trace can be continued on the outgoing requests with the context injected. Save the context to an X-Ray subsegment's metadata field, so the X-Ray trace can be converted to a Datadog trace in the Datadog backend with the correct context. """ global dd_trace_context headers = event.get("headers", {}) lowercase_headers = {k.lower(): v for k, v in headers.items()} trace_id = lowercase_headers.get(TraceHeader.TRACE_ID) parent_id = lowercase_headers.get(TraceHeader.PARENT_ID) sampling_priority = lowercase_headers.get(TraceHeader.SAMPLING_PRIORITY) if trace_id and parent_id and sampling_priority: logger.debug("Extracted Datadog trace context from headers") metadata = { "trace-id": trace_id, "parent-id": parent_id, "sampling-priority": sampling_priority, } xray_recorder.begin_subsegment(XraySubsegment.NAME) subsegment = xray_recorder.current_subsegment() subsegment.put_metadata(XraySubsegment.KEY, metadata, XraySubsegment.NAMESPACE) dd_trace_context = metadata.copy() dd_trace_context["source"] = TraceContextSource.EVENT xray_recorder.end_subsegment() else: # AWS Lambda runtime caches global variables between invocations, # reset to avoid using the context from the last invocation. dd_trace_context = _get_xray_trace_context() logger.debug("extracted dd trace context %s", dd_trace_context) return dd_trace_context def get_dd_trace_context(): """ Return the Datadog trace context to be propogated on the outgoing requests. If the Lambda function is invoked by a Datadog-traced service, a Datadog trace context may already exist, and it should be used. Otherwise, use the current X-Ray trace entity, or the dd-trace-py context if DD_TRACE_ENABLED is true. Most of widely-used HTTP clients are patched to inject the context automatically, but this function can be used to manually inject the trace context to an outgoing request. """ global dd_trace_context context = None xray_context = None try: xray_context = _get_xray_trace_context() # xray (sub)segment except Exception as e: logger.debug( "get_dd_trace_context couldn't read from segment from x-ray, with error %s" % e ) if xray_context and not dd_trace_context: context = xray_context elif xray_context and dd_trace_context: context = dd_trace_context.copy() context["parent-id"] = xray_context["parent-id"] if dd_tracing_enabled: dd_trace_py_context = _get_dd_trace_py_context() if dd_trace_py_context is not None: logger.debug("get_dd_trace_context using dd-trace context") context = dd_trace_py_context return _context_obj_to_headers(context) if context is not None else {} def set_correlation_ids(): """ Create a dummy span, and overrides its trace_id and span_id, to make ddtrace.helpers.get_correlation_ids() return the correct ids for both auto and manual log correlations. TODO: Remove me when Datadog tracer is natively supported in Lambda. """ if not is_lambda_context(): logger.debug("set_correlation_ids is only supported in LambdaContext") return if dd_tracing_enabled: logger.debug("using ddtrace implementation for spans") return context = get_dd_trace_context() span = tracer.trace("dummy.span") span.trace_id = context[TraceHeader.TRACE_ID] span.span_id = context[TraceHeader.PARENT_ID] logger.debug("correlation ids set") def inject_correlation_ids(): """ Override the formatter of LambdaLoggerHandler to inject datadog trace and span id for log correlation. For manual injections to custom log handlers, use `ddtrace.helpers.get_correlation_ids` to retrieve correlation ids (trace_id, span_id). """ # Override the log format of the AWS provided LambdaLoggerHandler root_logger = logging.getLogger() for handler in root_logger.handlers: if handler.__class__.__name__ == "LambdaLoggerHandler": handler.setFormatter( logging.Formatter( "[%(levelname)s]\t%(asctime)s.%(msecs)dZ\t%(aws_request_id)s\t" "[dd.trace_id=%(dd.trace_id)s dd.span_id=%(dd.span_id)s]\t%(message)s\n", "%Y-%m-%dT%H:%M:%S", ) ) # Patch `logging.Logger.makeRecord` to actually inject correlation ids patch(logging=True) logger.debug("logs injection configured") def is_lambda_context(): """ Return True if the X-Ray context is `LambdaContext`, rather than the regular `Context` (e.g., when testing lambda functions locally). """ return type(xray_recorder.context) == LambdaContext def set_dd_trace_py_root(trace_context, merge_xray_traces): if trace_context["source"] == TraceContextSource.EVENT or merge_xray_traces: headers = get_dd_trace_context() span_context = propagator.extract(headers) tracer.context_provider.activate(span_context) def create_function_execution_span( context, function_name, is_cold_start, trace_context, merge_xray_traces ): tags = {} if context: function_arn = (context.invoked_function_arn or "").lower() tags = { "cold_start": str(is_cold_start).lower(), "function_arn": function_arn, "request_id": context.aws_request_id, "resource_names": context.function_name, } source = trace_context["source"] if source == TraceContextSource.XRAY and merge_xray_traces: tags["_dd.parent_source"] = source args = { "service": "aws.lambda", "resource": function_name, "span_type": "serverless", } tracer.set_tags({"_dd.origin": "lambda"}) span = tracer.trace("aws.lambda", **args) if span: span.set_tags(tags) return span datadog-lambda-python-18/datadog_lambda/wrapper.py000066400000000000000000000107361366355203100224140ustar00rootroot00000000000000# 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. import os import logging import traceback from datadog_lambda.cold_start import set_cold_start, is_cold_start from datadog_lambda.metric import ( lambda_stats, submit_invocations_metric, submit_errors_metric, ) from datadog_lambda.patch import patch_all from datadog_lambda.tracing import ( extract_dd_trace_context, inject_correlation_ids, dd_tracing_enabled, set_correlation_ids, set_dd_trace_py_root, create_function_execution_span, ) logger = logging.getLogger(__name__) """ Usage: import requests from datadog_lambda.wrapper import datadog_lambda_wrapper from datadog_lambda.metric import lambda_metric @datadog_lambda_wrapper def my_lambda_handle(event, context): lambda_metric("my_metric", 10) requests.get("https://www.datadoghq.com") """ class _NoopDecorator(object): def __init__(self, func): self.func = func def __call__(self, *args, **kwargs): return self.func(*args, **kwargs) class _LambdaDecorator(object): """ Decorator to automatically initialize Datadog API client, flush metrics, and extracts/injects trace context. """ _force_wrap = False def __new__(cls, func): """ If the decorator is accidentally applied to the same function multiple times, wrap only once. If _force_wrap, always return a real decorator, useful for unit tests. """ try: if cls._force_wrap or not isinstance(func, _LambdaDecorator): wrapped = super(_LambdaDecorator, cls).__new__(cls) logger.debug("datadog_lambda_wrapper wrapped") return wrapped else: logger.debug("datadog_lambda_wrapper already wrapped") return _NoopDecorator(func) except Exception: traceback.print_exc() return func def __init__(self, func): """Executes when the wrapped function gets wrapped""" try: self.func = func self.flush_to_log = os.environ.get("DD_FLUSH_TO_LOG", "").lower() == "true" self.logs_injection = ( os.environ.get("DD_LOGS_INJECTION", "true").lower() == "true" ) self.merge_xray_traces = ( os.environ.get("DD_MERGE_XRAY_TRACES", "false").lower() == "true" ) self.function_name = os.environ.get("AWS_LAMBDA_FUNCTION_NAME", "function") # Inject trace correlation ids to logs if self.logs_injection: inject_correlation_ids() # Patch third-party libraries for tracing patch_all() logger.debug("datadog_lambda_wrapper initialized") except Exception: traceback.print_exc() def __call__(self, event, context, **kwargs): """Executes when the wrapped function gets called""" self._before(event, context) try: return self.func(event, context, **kwargs) except Exception: submit_errors_metric(context) raise finally: self._after(event, context) def _before(self, event, context): try: set_cold_start() submit_invocations_metric(context) # Extract Datadog trace context from incoming requests dd_context = extract_dd_trace_context(event) self.span = None if dd_tracing_enabled: set_dd_trace_py_root(dd_context, self.merge_xray_traces) self.span = create_function_execution_span( context, self.function_name, is_cold_start(), dd_context, self.merge_xray_traces, ) else: set_correlation_ids() logger.debug("datadog_lambda_wrapper _before() done") except Exception: traceback.print_exc() def _after(self, event, context): try: if not self.flush_to_log: lambda_stats.flush(float("inf")) if self.span: self.span.finish() logger.debug("datadog_lambda_wrapper _after() done") except Exception: traceback.print_exc() datadog_lambda_wrapper = _LambdaDecorator datadog-lambda-python-18/scripts/000077500000000000000000000000001366355203100171375ustar00rootroot00000000000000datadog-lambda-python-18/scripts/build_layers.sh000077500000000000000000000031451366355203100221570ustar00rootroot00000000000000#!/bin/sh # 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. # Builds Datadogpy layers for lambda functions, using Docker set -e LAYER_DIR=".layers" LAYER_FILES_PREFIX="datadog_lambda_py" PYTHON_VERSIONS=("2.7" "3.6" "3.7" "3.8") function make_path_absolute { echo "$(cd "$(dirname "$1")"; pwd)/$(basename "$1")" } function docker_build_zip { # Args: [python version] [zip destination] destination=$(make_path_absolute $2) # Install datadogpy in a docker container to avoid the mess from switching # between different python runtimes. temp_dir=$(mktemp -d) docker build -t datadog-lambda-layer-python:$1 . --no-cache \ --build-arg image=python:$1 \ --build-arg runtime=python$1 # Run the image by runtime tag, tar its generatd `python` directory to sdout, # then extract it to a temp directory. docker run datadog-lambda-layer-python:$1 tar cf - python | tar -xf - -C $temp_dir # Zip to destination, and keep directory structure as based in $temp_dir (cd $temp_dir && zip -q -r $destination ./) rm -rf $temp_dir echo "Done creating archive $destination" } rm -rf $LAYER_DIR mkdir $LAYER_DIR for python_version in "${PYTHON_VERSIONS[@]}" do echo "Building layer for python${python_version}" docker_build_zip ${python_version} $LAYER_DIR/${LAYER_FILES_PREFIX}${python_version}.zip done echo "Done creating layers:" ls $LAYER_DIR | xargs -I _ echo "$LAYER_DIR/_" datadog-lambda-python-18/scripts/check_format.sh000077500000000000000000000004711366355203100221250ustar00rootroot00000000000000#!/bin/sh set -e PYTHON_VERSION=$(python -c 'import sys; print(sys.version_info.major)') if [ "$PYTHON_VERSION" = "2" ]; then echo "Skipping formatting, black not compatible with python 2" exit 0 fi pip install -Iv black==19.10b0 python -m black --check datadog_lambda/ python -m black --check tests datadog-lambda-python-18/scripts/list_layers.sh000077500000000000000000000036101366355203100220300ustar00rootroot00000000000000#!/bin/bash # 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. # Lists most recent layers ARNs across regions to STDOUT # Optionals args: [layer-name] [region] LAYER_NAMES=("Datadog-Python27" "Datadog-Python36" "Datadog-Python37" "Datadog-Python38") AVAILABLE_REGIONS=(us-east-2 us-east-1 us-west-1 us-west-2 ap-east-1 ap-south-1 ap-northeast-2 ap-southeast-1 ap-southeast-2 ap-northeast-1 ca-central-1 eu-north-1 eu-central-1 eu-west-1 eu-west-2 eu-west-3 sa-east-1) # Check region arg if [ -z "$2" ]; then >&2 echo "Region parameter not specified, running for all available regions." REGIONS=("${AVAILABLE_REGIONS[@]}") else >&2 echo "Region parameter specified: $2" if [[ ! " ${AVAILABLE_REGIONS[@]} " =~ " ${2} " ]]; then >&2 echo "Could not find $2 in available regions: ${AVAILABLE_REGIONS[@]}" >&2 echo "" >&2 echo "EXITING SCRIPT." return 1 fi REGIONS=($2) fi # Check region arg if [ -z "$1" ]; then >&2 echo "Layer parameter not specified, running for all layers " LAYERS=("${LAYER_NAMES[@]}") else >&2 echo "Layer parameter specified: $1" if [[ ! " ${LAYER_NAMES[@]} " =~ " ${1} " ]]; then >&2 echo "Could not find $1 in layers: ${LAYER_NAMES[@]}" >&2 echo "" >&2 echo "EXITING SCRIPT." return 1 fi LAYERS=($1) fi for region in "${REGIONS[@]}" do for layer_name in "${LAYERS[@]}" do last_layer_arn=$(aws lambda list-layer-versions --layer-name $layer_name --region $region | jq -r ".LayerVersions | .[0] | .LayerVersionArn") if [ -z $last_layer_arn ]; then >&2 echo "No layer found for $region, $layer_name" else echo $last_layer_arn fi done done datadog-lambda-python-18/scripts/publish_layers.sh000077500000000000000000000072501366355203100225270ustar00rootroot00000000000000#!/bin/bash # 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. # Publish the datadog python lambda layer across regions, using the AWS CLI # Usage: publish_layer.sh [region] [layer] # Specifying the region and layer arg will publish the specified layer to the specified region set -e # Makes sure any subprocesses will be terminated with this process trap "pkill -P $$; exit 1;" INT PYTHON_VERSIONS_FOR_AWS_CLI=("python2.7" "python3.6" "python3.7" "python3.8") LAYER_PATHS=(".layers/datadog_lambda_py2.7.zip" ".layers/datadog_lambda_py3.6.zip" ".layers/datadog_lambda_py3.7.zip" ".layers/datadog_lambda_py3.8.zip") AVAILABLE_LAYER_NAMES=("Datadog-Python27" "Datadog-Python36" "Datadog-Python37" "Datadog-Python38") AVAILABLE_REGIONS=(us-east-2 us-east-1 us-west-1 us-west-2 ap-east-1 ap-south-1 ap-northeast-2 ap-southeast-1 ap-southeast-2 ap-northeast-1 ca-central-1 eu-north-1 eu-central-1 eu-west-1 eu-west-2 eu-west-3 sa-east-1) # Check that the layer files exist for layer_file in "${LAYER_PATHS[@]}" do if [ ! -f $layer_file ]; then echo "Could not find $layer_file." exit 1 fi done # Check region arg if [ -z "$1" ]; then echo "Region parameter not specified, running for all available regions." REGIONS=("${AVAILABLE_REGIONS[@]}") else echo "Region parameter specified: $1" if [[ ! " ${AVAILABLE_REGIONS[@]} " =~ " ${1} " ]]; then echo "Could not find $1 in available regions: ${AVAILABLE_REGIONS[@]}" echo "" echo "EXITING SCRIPT." exit 1 fi REGIONS=($1) fi echo "Publishing layers for regions: ${REGIONS[*]}" # Check layer_name arg if [ -z "$2" ]; then echo "Layer name parameter not specified, running for all layer names." LAYER_NAMES=("${AVAILABLE_LAYER_NAMES[@]}") else echo "Layer name parameter specified: $2" if [[ ! " ${AVAILABLE_LAYER_NAMES[@]} " =~ " ${2} " ]]; then echo "Could not find $2 in available layer names: ${AVAILABLE_LAYER_NAMES[@]}" echo "" echo "EXITING SCRIPT." exit 1 fi LAYER_NAMES=($2) fi echo "Publishing layers: ${LAYER_NAMES[*]}" publish_layer() { region=$1 layer_name=$2 aws_version_key=$3 layer_path=$4 version_nbr=$(aws lambda publish-layer-version --layer-name $layer_name \ --description "Datadog Lambda Layer for Python" \ --zip-file "fileb://$layer_path" \ --region $region \ --compatible-runtimes $aws_version_key \ | jq -r '.Version') aws lambda add-layer-version-permission --layer-name $layer_name \ --version-number $version_nbr \ --statement-id "release-$version_nbr" \ --action lambda:GetLayerVersion --principal "*" \ --region $region echo "Published layer for region $region, python version $aws_version_key, layer_name $layer_name, layer_version $version_nbr" } BATCH_SIZE=60 PIDS=() wait_for_processes() { for pid in "${PIDS[@]}"; do wait $pid done PIDS=() } for region in "${REGIONS[@]}" do echo "Starting publishing layer for region $region..." # Publish the layers for each version of python i=0 for layer_name in "${LAYER_NAMES[@]}"; do aws_version_key="${PYTHON_VERSIONS_FOR_AWS_CLI[$i]}" layer_path="${LAYER_PATHS[$i]}" publish_layer $region $layer_name $aws_version_key $layer_path & PIDS+=($!) if [ ${#PIDS[@]} -eq $BATCH_SIZE ]; then wait_for_processes fi i=$(expr $i + 1) done done wait_for_processes echo "Done !" datadog-lambda-python-18/scripts/publish_staging.sh000077500000000000000000000001231366355203100226540ustar00rootroot00000000000000#!/bin/bash set -e ./scripts/build_layers.sh ./scripts/publish_layers.sh us-east-1datadog-lambda-python-18/scripts/pypi.sh000077500000000000000000000011721366355203100204600ustar00rootroot00000000000000#!/bin/sh # 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. # Builds the lambda layer and upload to Pypi set -e # Clear previously built distributions if [ -d "dist" ]; then echo "Removing folder 'dist' to clear previously built distributions" rm -rf dist; fi # Install build tools pip install --upgrade setuptools wheel twine # Build distributions python setup.py sdist bdist_wheel # Upload distributions python -m twine upload dist/* datadog-lambda-python-18/scripts/run_integration_tests.sh000077500000000000000000000162321366355203100241330ustar00rootroot00000000000000#!/bin/bash # Usage - run commands from repo root: # To check if new changes to the layer cause changes to any snapshots: # BUILD_LAYERS=true DD_API_KEY=XXXX aws-vault exec sandbox-account-admin -- ./scripts/run_integration_tests # To regenerate snapshots: # UPDATE_SNAPSHOTS=true DD_API_KEY=XXXX aws-vault exec sandbox-account-admin -- ./scripts/run_integration_tests set -e # These values need to be in sync with serverless.yml, where there needs to be a function # defined for every handler_runtime combination LAMBDA_HANDLERS=("async-metrics" "sync-metrics" "http-requests") RUNTIMES=("python27" "python36" "python37" "python38") LOGS_WAIT_SECONDS=20 script_path=${BASH_SOURCE[0]} scripts_dir=$(dirname $script_path) repo_dir=$(dirname $scripts_dir) integration_tests_dir="$repo_dir/tests/integration" script_start_time=$(date --iso-8601=seconds) mismatch_found=false if [ -z "$DD_API_KEY" ]; then echo "No DD_API_KEY env var set, exiting" exit 1 fi if [ -n "$UPDATE_SNAPSHOTS" ]; then echo "Overwriting snapshots in this execution" fi if [ -n "$BUILD_LAYERS" ]; then echo "Building layers that will be deployed with our test functions" source $scripts_dir/build_layers.sh else echo "Not building layers, ensure they've already been built or re-run with 'BUILD_LAYERS=true DD_API_KEY=XXXX ./scripts/run_integration_tests.sh'" fi cd $integration_tests_dir input_event_files=$(ls ./input_events) # Sort event files by name so that snapshots stay consistent input_event_files=($(for file_name in ${input_event_files[@]}; do echo $file_name; done | sort)) echo "Deploying functions" serverless deploy echo "Invoking functions" set +e # Don't exit this script if an invocation fails or there's a diff for handler_name in "${LAMBDA_HANDLERS[@]}"; do for runtime in "${RUNTIMES[@]}"; do function_name="${handler_name}_${runtime}" # Invoke function once for each input event for input_event_file in "${input_event_files[@]}"; do # Get event name without trailing ".json" so we can build the snapshot file name input_event_name=$(echo "$input_event_file" | sed "s/.json//") # Return value snapshot file format is snapshots/return_values/{handler}_{runtime}_{input-event} snapshot_path="./snapshots/return_values/${function_name}_${input_event_name}.json" return_value=$(serverless invoke -f $function_name --path "./input_events/$input_event_file") if [ ! -f $snapshot_path ]; then # If the snapshot file doesn't exist yet, we create it echo "Writing return value to $snapshot_path because no snapshot exists yet" echo "$return_value" >$snapshot_path elif [ -n "$UPDATE_SNAPSHOTS" ]; then # If $UPDATE_SNAPSHOTS is set to true, write the new logs over the current snapshot echo "Overwriting return value snapshot for $snapshot_path" echo "$return_value" >$snapshot_path else # Compare new return value to snapshot diff_output=$(echo "$return_value" | diff - $snapshot_path) if [ $? -eq 1 ]; then echo "Failed: Return value for $function_name does not match snapshot:" echo "$diff_output" mismatch_found=true else echo "Ok: Return value for $function_name with $input_event_name event matches snapshot" fi fi done done done set -e echo "Sleeping $LOGS_WAIT_SECONDS seconds to wait for logs to appear in CloudWatch..." sleep $LOGS_WAIT_SECONDS echo "Fetching logs for invocations and comparing to snapshots" for handler_name in "${LAMBDA_HANDLERS[@]}"; do for runtime in "${RUNTIMES[@]}"; do function_name="${handler_name}_${runtime}" function_snapshot_path="./snapshots/logs/$function_name.log" # Fetch logs with serverless cli raw_logs=$(serverless logs -f $function_name --startTime $script_start_time) # Replace invocation-specific data like timestamps and IDs with XXXX to normalize logs across executions logs=$( echo "$raw_logs" | # Filter serverless cli errors sed '/Serverless: Recoverable error occurred/d' | # Remove blank lines sed '/^$/d' | # Normalize Lambda runtime report logs sed -E 's/(RequestId|TraceId|SegmentId|Duration|Memory Used|"e"): [a-z0-9\.\-]+/\1: XXXX/g' | # Normalize DD APM headers and AWS account ID sed -E "s/(x-datadog-parent-id:|x-datadog-trace-id:|account_id:)[0-9]+/\1XXXX/g" | # Normalize timestamps in datapoints POSTed to DD sed -E 's/"points": \[\[[0-9\.]+,/"points": \[\[XXXX,/g' | # Strip API key from logged requests sed -E "s/(api_key=|'api_key': ')[a-z0-9\.\-]+/\1XXXX/g" | # Normalize minor package version so that these snapshots aren't broken on version bumps sed -E "s/(dd_lambda_layer:datadog-python[0-9]+_2\.)[0-9]+\.0/\1XX\.0/g" | # Strip out trace/span/parent/timestamps sed -E "s/(\"trace_id\"\: \")[A-Z0-9\.\-]+/\1XXXX/g" | sed -E "s/(\"span_id\"\: \")[A-Z0-9\.\-]+/\1XXXX/g" | sed -E "s/(\"parent_id\"\: \")[A-Z0-9\.\-]+/\1XXXX/g" | sed -E "s/(\"request_id\"\: \")[a-z0-9\.\-]+/\1XXXX/g" | sed -E "s/(\"duration\"\: )[0-9\.\-]+/\1XXXX/g" | sed -E "s/(\"start\"\: )[0-9\.\-]+/\1XXXX/g" | sed -E "s/(\"system\.pid\"\: )[0-9\.\-]+/\1XXXX/g" ) if [ ! -f $function_snapshot_path ]; then # If no snapshot file exists yet, we create one echo "Writing logs to $function_snapshot_path because no snapshot exists yet" echo "$logs" >$function_snapshot_path elif [ -n "$UPDATE_SNAPSHOTS" ]; then # If $UPDATE_SNAPSHOTS is set to true write the new logs over the current snapshot echo "Overwriting log snapshot for $function_snapshot_path" echo "$logs" >$function_snapshot_path else # Compare new logs to snapshots set +e # Don't exit this script if there is a diff diff_output=$(echo "$logs" | diff - $function_snapshot_path) if [ $? -eq 1 ]; then echo "Failed: Mismatch found between new $function_name logs (first) and snapshot (second):" echo "$diff_output" mismatch_found=true else echo "Ok: New logs for $function_name match snapshot" fi set -e fi done done if [ "$mismatch_found" = true ]; then echo "FAILURE: A mismatch between new data and a snapshot was found and printed above." echo "If the change is expected, generate new snapshots by running 'UPDATE_SNAPSHOTS=true DD_API_KEY=XXXX ./scripts/run_integration_tests.sh'" exit 1 fi if [ -n "$UPDATE_SNAPSHOTS" ]; then echo "SUCCESS: Wrote new snapshots for all functions" exit 0 fi echo "SUCCESS: No difference found between snapshots and new return values or logs" datadog-lambda-python-18/scripts/run_tests.sh000077500000000000000000000016471366355203100215340ustar00rootroot00000000000000#!/bin/bash # 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. # Run unit tests in Docker set -e PYTHON_VERSIONS=("2.7" "3.6" "3.7" "3.8") for python_version in "${PYTHON_VERSIONS[@]}" do echo "Running tests against python${python_version}" docker build -t datadog-lambda-layer-python-test:$python_version \ -f tests/Dockerfile . \ --build-arg python_version=$python_version docker run -v `pwd`:/datadog-lambda-layer-python \ -w /datadog-lambda-layer-python \ datadog-lambda-layer-python-test:$python_version \ nose2 -v docker run -v `pwd`:/datadog-lambda-layer-python \ -w /datadog-lambda-layer-python \ datadog-lambda-layer-python-test:$python_version \ flake8 done datadog-lambda-python-18/setup.py000066400000000000000000000023421366355203100171630ustar00rootroot00000000000000from setuptools import setup from os import path from io import open from datadog_lambda import __version__ here = path.abspath(path.dirname(__file__)) with open(path.join(here, "README.md"), encoding="utf-8") as f: long_description = f.read() setup( name="datadog_lambda", version=__version__, description="The Datadog AWS Lambda Layer", long_description=long_description, long_description_content_type="text/markdown", url="https://github.com/DataDog/datadog-lambda-layer-python", author="Datadog, Inc.", author_email="dev@datadoghq.com", classifiers=[ "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", ], keywords="datadog aws lambda layer", packages=["datadog_lambda"], python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, <4", install_requires=[ "aws-xray-sdk==2.5.0", "datadog==0.32.0", "ddtrace==0.36.0", "wrapt==1.11.2", "setuptools==42.0.2", ], extras_require={ "dev": ["nose2==0.9.1", "flake8==3.7.9", "requests==2.22.0", "boto3==1.10.33"] }, ) datadog-lambda-python-18/tests/000077500000000000000000000000001366355203100166125ustar00rootroot00000000000000datadog-lambda-python-18/tests/Dockerfile000066400000000000000000000003151366355203100206030ustar00rootroot00000000000000ARG python_version FROM python:$python_version ENV PYTHONDONTWRITEBYTECODE True RUN mkdir -p /test WORKDIR /test # Install datadog-lambda with dev dependencies from local COPY . . RUN pip install .[dev]datadog-lambda-python-18/tests/__init__.py000066400000000000000000000000001366355203100207110ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/000077500000000000000000000000001366355203100211355ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/handle.py000066400000000000000000000017561366355203100227530ustar00rootroot00000000000000from datadog_lambda.metric import lambda_metric from datadog_lambda.wrapper import datadog_lambda_wrapper @datadog_lambda_wrapper def handle(event, context): # Parse request ID and record ids out of the event to include in the response request_id = event.get("requestContext", {}).get("requestId") event_records = event.get("Records", []) record_ids = [] for record in event_records: # SQS if record.get("messageId"): record_ids.append(record["messageId"]) # SNS if record.get("Sns", {}).get("MessageId"): record_ids.append(record["Sns"]["MessageId"]) lambda_metric("hello.dog", 1, tags=["team:serverless", "role:hello"]) lambda_metric( "tests.integration.count", 21, tags=["test:integration", "role:hello"] ) return { "statusCode": 200, "body": { "message": "hello, dog!", "request_id": request_id, "event_record_ids": record_ids, }, } datadog-lambda-python-18/tests/integration/http_requests.py000066400000000000000000000011671366355203100244260ustar00rootroot00000000000000import requests from datadog_lambda.metric import lambda_metric from datadog_lambda.wrapper import datadog_lambda_wrapper from ddtrace import tracer from ddtrace.internal.writer import LogWriter tracer.writer = LogWriter() @datadog_lambda_wrapper def handle(event, context): lambda_metric("hello.dog", 1, tags=["team:serverless", "role:hello"]) lambda_metric( "tests.integration.count", 21, tags=["test:integration", "role:hello"] ) requests.get("https://ip-ranges.datadoghq.com/") requests.get("https://ip-ranges.datadoghq.eu/") return {"statusCode": 200, "body": {"message": "hello, dog!"}} datadog-lambda-python-18/tests/integration/input_events/000077500000000000000000000000001366355203100236605ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/input_events/api-gateway-get.json000066400000000000000000000036511366355203100275450ustar00rootroot00000000000000{ "path": "/test/hello", "headers": { "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8", "Accept-Encoding": "gzip, deflate, lzma, sdch, br", "Accept-Language": "en-US,en;q=0.8", "CloudFront-Forwarded-Proto": "https", "CloudFront-Is-Desktop-Viewer": "true", "CloudFront-Is-Mobile-Viewer": "false", "CloudFront-Is-SmartTV-Viewer": "false", "CloudFront-Is-Tablet-Viewer": "false", "CloudFront-Viewer-Country": "US", "Host": "wt6mne2s9k.execute-api.us-west-2.amazonaws.com", "Upgrade-Insecure-Requests": "1", "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36 OPR/39.0.2256.48", "Via": "1.1 fb7cca60f0ecd82ce07790c9c5eef16c.cloudfront.net (CloudFront)", "X-Amz-Cf-Id": "nBsWBOrSHMgnaROZJK1wGCZ9PcRcSpq_oSXZNQwQ10OTZL4cimZo3g==", "X-Forwarded-For": "192.168.100.1, 192.168.1.1", "X-Forwarded-Port": "443", "X-Forwarded-Proto": "https" }, "pathParameters": { "proxy": "hello" }, "requestContext": { "accountId": "123456789012", "resourceId": "us4z18", "stage": "test", "requestId": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9", "identity": { "cognitoIdentityPoolId": "", "accountId": "", "cognitoIdentityId": "", "caller": "", "apiKey": "", "sourceIp": "192.168.100.1", "cognitoAuthenticationType": "", "cognitoAuthenticationProvider": "", "userArn": "", "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36 OPR/39.0.2256.48", "user": "" }, "resourcePath": "/{proxy+}", "httpMethod": "GET", "apiId": "wt6mne2s9k" }, "resource": "/{proxy+}", "httpMethod": "GET", "queryStringParameters": { "name": "me" }, "stageVariables": { "stageVarName": "stageVarValue" } } datadog-lambda-python-18/tests/integration/input_events/sns.json000066400000000000000000000022501366355203100253550ustar00rootroot00000000000000{ "Records": [ { "EventVersion": "1.0", "EventSubscriptionArn": "arn:aws:sns:us-east-2:123456789012:sns-lambda:21be56ed-a058-49f5-8c98-aedd2564c486", "EventSource": "aws:sns", "Sns": { "SignatureVersion": "1", "Timestamp": "2019-01-02T12:45:07.000Z", "Signature": "tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==", "SigningCertUrl": "https://sns.us-east-2.amazonaws.com/SimpleNotificationService-ac565b8b1a6c5d002d285f9598aa1d9b.pem", "MessageId": "95df01b4-ee98-5cb9-9903-4c221d41eb5e", "Message": "Hello from SNS!", "MessageAttributes": { "Test": { "Type": "String", "Value": "TestString" }, "TestBinary": { "Type": "Binary", "Value": "TestBinary" } }, "Type": "Notification", "UnsubscribeUrl": "https://sns.us-east-2.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-lambda:21be56ed-a058-49f5-8c98-aedd2564c486", "TopicArn": "arn:aws:sns:us-east-2:123456789012:sns-lambda", "Subject": "TestInvoke" } } ] } datadog-lambda-python-18/tests/integration/input_events/sqs.json000066400000000000000000000023201366355203100253560ustar00rootroot00000000000000{ "Records": [ { "messageId": "059f36b4-87a3-44ab-83d2-661975830a7d", "receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...", "body": "Test message.", "attributes": { "ApproximateReceiveCount": "1", "SentTimestamp": "1545082649183", "SenderId": "AIDAIENQZJOLO23YVJ4VO", "ApproximateFirstReceiveTimestamp": "1545082649185" }, "messageAttributes": {}, "md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3", "eventSource": "aws:sqs", "eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue", "awsRegion": "us-east-2" }, { "messageId": "2e1424d4-f796-459a-8184-9c92662be6da", "receiptHandle": "AQEBzWwaftRI0KuVm4tP+/7q1rGgNqicHq...", "body": "Test message.", "attributes": { "ApproximateReceiveCount": "1", "SentTimestamp": "1545082650636", "SenderId": "AIDAIENQZJOLO23YVJ4VO", "ApproximateFirstReceiveTimestamp": "1545082650649" }, "messageAttributes": {}, "md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3", "eventSource": "aws:sqs", "eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue", "awsRegion": "us-east-2" } ] } datadog-lambda-python-18/tests/integration/serverless.yml000066400000000000000000000046501366355203100240620ustar00rootroot00000000000000service: integration-tester provider: name: aws tracing: lambda: true apiGateway: true environment: DD_INTEGRATION_TEST: true DD_API_KEY: ${env:DD_API_KEY} layers: python27: package: artifact: ../../.layers/datadog_lambda_py2.7.zip python36: package: artifact: ../../.layers/datadog_lambda_py3.6.zip python37: package: artifact: ../../.layers/datadog_lambda_py3.7.zip python38: package: artifact: ../../.layers/datadog_lambda_py3.8.zip functions: # async-metrics async-metrics_python27: handler: handle.handle runtime: python2.7 layers: - { Ref: Python27LambdaLayer } environment: DD_FLUSH_TO_LOG: true async-metrics_python36: handler: handle.handle runtime: python3.6 layers: - { Ref: Python36LambdaLayer } environment: DD_FLUSH_TO_LOG: true async-metrics_python37: handler: handle.handle runtime: python3.7 layers: - { Ref: Python37LambdaLayer } environment: DD_FLUSH_TO_LOG: true async-metrics_python38: handler: handle.handle runtime: python3.8 layers: - { Ref: Python38LambdaLayer } environment: DD_FLUSH_TO_LOG: true # sync-metrics sync-metrics_python27: handler: handle.handle runtime: python2.7 layers: - { Ref: Python27LambdaLayer } sync-metrics_python36: handler: handle.handle runtime: python3.6 layers: - { Ref: Python36LambdaLayer } sync-metrics_python37: handler: handle.handle runtime: python3.7 layers: - { Ref: Python37LambdaLayer } sync-metrics_python38: handler: handle.handle runtime: python3.8 layers: - { Ref: Python38LambdaLayer } # http-requests http-requests_python27: handler: http_requests.handle runtime: python2.7 environment: DD_TRACE_ENABLED: true layers: - { Ref: Python27LambdaLayer } http-requests_python36: handler: http_requests.handle runtime: python3.6 environment: DD_TRACE_ENABLED: true layers: - { Ref: Python36LambdaLayer } http-requests_python37: handler: http_requests.handle runtime: python3.7 environment: DD_TRACE_ENABLED: true layers: - { Ref: Python37LambdaLayer } http-requests_python38: handler: http_requests.handle runtime: python3.8 environment: DD_TRACE_ENABLED: true layers: - { Ref: Python38LambdaLayer } datadog-lambda-python-18/tests/integration/snapshots/000077500000000000000000000000001366355203100231575ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/logs/000077500000000000000000000000001366355203100241235ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/logs/async-metrics_python27.log000066400000000000000000000043431366355203100311650ustar00rootroot00000000000000START RequestId: XXXX Version: $LATEST {"e": XXXX, "m": "aws.lambda.enhanced.invocations", "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-async-metrics_python27", "cold_start:true", "memorysize:1024", "runtime:python2.7", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 1} {"e": XXXX, "m": "hello.dog", "t": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 1} {"e": XXXX, "m": "tests.integration.count", "t": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 21} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB Init Duration: XXXX ms XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"e": XXXX, "m": "aws.lambda.enhanced.invocations", "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-async-metrics_python27", "cold_start:false", "memorysize:1024", "runtime:python2.7", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 1} {"e": XXXX, "m": "hello.dog", "t": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 1} {"e": XXXX, "m": "tests.integration.count", "t": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 21} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"e": XXXX, "m": "aws.lambda.enhanced.invocations", "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-async-metrics_python27", "cold_start:false", "memorysize:1024", "runtime:python2.7", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 1} {"e": XXXX, "m": "hello.dog", "t": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 1} {"e": XXXX, "m": "tests.integration.count", "t": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 21} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true datadog-lambda-python-18/tests/integration/snapshots/logs/async-metrics_python36.log000066400000000000000000000043431366355203100311650ustar00rootroot00000000000000START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-async-metrics_python36", "cold_start:true", "memorysize:1024", "runtime:python3.6", "dd_lambda_layer:datadog-python36_2.XX.0"]} {"m": "hello.dog", "v": 1, "e": XXXX, "t": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"]} {"m": "tests.integration.count", "v": 21, "e": XXXX, "t": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB Init Duration: XXXX ms XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-async-metrics_python36", "cold_start:false", "memorysize:1024", "runtime:python3.6", "dd_lambda_layer:datadog-python36_2.XX.0"]} {"m": "hello.dog", "v": 1, "e": XXXX, "t": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"]} {"m": "tests.integration.count", "v": 21, "e": XXXX, "t": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-async-metrics_python36", "cold_start:false", "memorysize:1024", "runtime:python3.6", "dd_lambda_layer:datadog-python36_2.XX.0"]} {"m": "hello.dog", "v": 1, "e": XXXX, "t": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"]} {"m": "tests.integration.count", "v": 21, "e": XXXX, "t": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true datadog-lambda-python-18/tests/integration/snapshots/logs/async-metrics_python37.log000066400000000000000000000043431366355203100311660ustar00rootroot00000000000000START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-async-metrics_python37", "cold_start:true", "memorysize:1024", "runtime:python3.7", "dd_lambda_layer:datadog-python37_2.XX.0"]} {"m": "hello.dog", "v": 1, "e": XXXX, "t": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"]} {"m": "tests.integration.count", "v": 21, "e": XXXX, "t": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB Init Duration: XXXX ms XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-async-metrics_python37", "cold_start:false", "memorysize:1024", "runtime:python3.7", "dd_lambda_layer:datadog-python37_2.XX.0"]} {"m": "hello.dog", "v": 1, "e": XXXX, "t": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"]} {"m": "tests.integration.count", "v": 21, "e": XXXX, "t": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-async-metrics_python37", "cold_start:false", "memorysize:1024", "runtime:python3.7", "dd_lambda_layer:datadog-python37_2.XX.0"]} {"m": "hello.dog", "v": 1, "e": XXXX, "t": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"]} {"m": "tests.integration.count", "v": 21, "e": XXXX, "t": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true datadog-lambda-python-18/tests/integration/snapshots/logs/async-metrics_python38.log000066400000000000000000000043431366355203100311670ustar00rootroot00000000000000START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-async-metrics_python38", "cold_start:true", "memorysize:1024", "runtime:python3.8", "dd_lambda_layer:datadog-python38_2.XX.0"]} {"m": "hello.dog", "v": 1, "e": XXXX, "t": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"]} {"m": "tests.integration.count", "v": 21, "e": XXXX, "t": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB Init Duration: XXXX ms XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-async-metrics_python38", "cold_start:false", "memorysize:1024", "runtime:python3.8", "dd_lambda_layer:datadog-python38_2.XX.0"]} {"m": "hello.dog", "v": 1, "e": XXXX, "t": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"]} {"m": "tests.integration.count", "v": 21, "e": XXXX, "t": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-async-metrics_python38", "cold_start:false", "memorysize:1024", "runtime:python3.8", "dd_lambda_layer:datadog-python38_2.XX.0"]} {"m": "hello.dog", "v": 1, "e": XXXX, "t": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"]} {"m": "tests.integration.count", "v": 21, "e": XXXX, "t": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true datadog-lambda-python-18/tests/integration/snapshots/logs/http-requests_python27.log000066400000000000000000000246651366355203100312450ustar00rootroot00000000000000START RequestId: XXXX Version: $LATEST {"e": XXXX, "m": "aws.lambda.enhanced.invocations", "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-http-requests_python27", "cold_start:true", "memorysize:1024", "runtime:python2.7", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 1} HTTP GET https://ip-ranges.datadoghq.com/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP GET https://ip-ranges.datadoghq.eu/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {"series": [{"tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "metric": "hello.dog", "interval": 10, "host": null, "points": [[XXXX, [1.0]]], "device": null, "type": "distribution"}, {"tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "metric": "tests.integration.count", "interval": 10, "host": null, "points": [[XXXX, [21.0]]], "device": null, "type": "distribution"}]} {"traces": [[{"resource": "integration-tester-dev-http-requests_python27", "name": "aws.lambda", "service": "aws.lambda", "start": XXXX, "trace_id": "XXXX", "metrics": {"_sampling_priority_v1": 1, "system.pid": XXXX, "_dd.agent_psr": 1.0}, "parent_id": "XXXX", "meta": {"function_arn": "arn:aws:lambda:us-east-1:601427279990:function:integration-tester-dev-http-requests_python27", "resource_names": "integration-tester-dev-http-requests_python27", "cold_start": "true", "_dd.origin": "lambda", "_dd.parent_source": "xray", "request_id": "XXXX"}, "error": 0, "duration": XXXX, "type": "serverless", "span_id": "XXXX"}, {"resource": "requests.request", "name": "requests.request", "service": "aws.lambda", "start": XXXX, "trace_id": "XXXX", "metrics": {"_dd.measured": 1}, "parent_id": "XXXX", "meta": {"http.status_code": "200", "http.url": "https://ip-ranges.datadoghq.com/", "_dd.origin": "lambda", "http.method": "GET"}, "error": 0, "duration": XXXX, "type": "http", "span_id": "XXXX"}, {"resource": "requests.request", "name": "requests.request", "service": "aws.lambda", "start": XXXX, "trace_id": "XXXX", "metrics": {"_dd.measured": 1}, "parent_id": "XXXX", "meta": {"http.status_code": "200", "http.url": "https://ip-ranges.datadoghq.eu/", "_dd.origin": "lambda", "http.method": "GET"}, "error": 0, "duration": XXXX, "type": "http", "span_id": "XXXX"}, {"resource": "requests.request", "name": "requests.request", "service": "aws.lambda", "start": XXXX, "trace_id": "XXXX", "metrics": {"_dd.measured": 1}, "parent_id": "XXXX", "meta": {"http.status_code": "202", "http.url": "https://api.datadoghq.com/api/v1/distribution_points", "_dd.origin": "lambda", "http.method": "POST"}, "error": 0, "duration": XXXX, "type": "http", "span_id": "XXXX"}]]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB Init Duration: XXXX ms XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"e": XXXX, "m": "aws.lambda.enhanced.invocations", "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-http-requests_python27", "cold_start:false", "memorysize:1024", "runtime:python2.7", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 1} HTTP GET https://ip-ranges.datadoghq.com/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP GET https://ip-ranges.datadoghq.eu/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {"series": [{"tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "metric": "hello.dog", "interval": 10, "host": null, "points": [[XXXX, [1.0]]], "device": null, "type": "distribution"}, {"tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "metric": "tests.integration.count", "interval": 10, "host": null, "points": [[XXXX, [21.0]]], "device": null, "type": "distribution"}]} {"traces": [[{"resource": "integration-tester-dev-http-requests_python27", "name": "aws.lambda", "service": "aws.lambda", "start": XXXX, "trace_id": "XXXX", "metrics": {"_sampling_priority_v1": 1, "system.pid": XXXX, "_dd.agent_psr": 1.0}, "parent_id": "XXXX", "meta": {"function_arn": "arn:aws:lambda:us-east-1:601427279990:function:integration-tester-dev-http-requests_python27", "resource_names": "integration-tester-dev-http-requests_python27", "cold_start": "false", "_dd.origin": "lambda", "_dd.parent_source": "xray", "request_id": "XXXX"}, "error": 0, "duration": XXXX, "type": "serverless", "span_id": "XXXX"}, {"resource": "requests.request", "name": "requests.request", "service": "aws.lambda", "start": XXXX, "trace_id": "XXXX", "metrics": {"_dd.measured": 1}, "parent_id": "XXXX", "meta": {"http.status_code": "200", "http.url": "https://ip-ranges.datadoghq.com/", "_dd.origin": "lambda", "http.method": "GET"}, "error": 0, "duration": XXXX, "type": "http", "span_id": "XXXX"}, {"resource": "requests.request", "name": "requests.request", "service": "aws.lambda", "start": XXXX, "trace_id": "XXXX", "metrics": {"_dd.measured": 1}, "parent_id": "XXXX", "meta": {"http.status_code": "200", "http.url": "https://ip-ranges.datadoghq.eu/", "_dd.origin": "lambda", "http.method": "GET"}, "error": 0, "duration": XXXX, "type": "http", "span_id": "XXXX"}, {"resource": "requests.request", "name": "requests.request", "service": "aws.lambda", "start": XXXX, "trace_id": "XXXX", "metrics": {"_dd.measured": 1}, "parent_id": "XXXX", "meta": {"http.status_code": "202", "http.url": "https://api.datadoghq.com/api/v1/distribution_points", "_dd.origin": "lambda", "http.method": "POST"}, "error": 0, "duration": XXXX, "type": "http", "span_id": "XXXX"}]]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"e": XXXX, "m": "aws.lambda.enhanced.invocations", "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-http-requests_python27", "cold_start:false", "memorysize:1024", "runtime:python2.7", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 1} HTTP GET https://ip-ranges.datadoghq.com/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP GET https://ip-ranges.datadoghq.eu/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {"series": [{"tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "metric": "hello.dog", "interval": 10, "host": null, "points": [[XXXX, [1.0]]], "device": null, "type": "distribution"}, {"tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "metric": "tests.integration.count", "interval": 10, "host": null, "points": [[XXXX, [21.0]]], "device": null, "type": "distribution"}]} {"traces": [[{"resource": "integration-tester-dev-http-requests_python27", "name": "aws.lambda", "service": "aws.lambda", "start": XXXX, "trace_id": "XXXX", "metrics": {"_sampling_priority_v1": 1, "system.pid": XXXX, "_dd.agent_psr": 1.0}, "parent_id": "XXXX", "meta": {"function_arn": "arn:aws:lambda:us-east-1:601427279990:function:integration-tester-dev-http-requests_python27", "resource_names": "integration-tester-dev-http-requests_python27", "cold_start": "false", "_dd.origin": "lambda", "_dd.parent_source": "xray", "request_id": "XXXX"}, "error": 0, "duration": XXXX, "type": "serverless", "span_id": "XXXX"}, {"resource": "requests.request", "name": "requests.request", "service": "aws.lambda", "start": XXXX, "trace_id": "XXXX", "metrics": {"_dd.measured": 1}, "parent_id": "XXXX", "meta": {"http.status_code": "200", "http.url": "https://ip-ranges.datadoghq.com/", "_dd.origin": "lambda", "http.method": "GET"}, "error": 0, "duration": XXXX, "type": "http", "span_id": "XXXX"}, {"resource": "requests.request", "name": "requests.request", "service": "aws.lambda", "start": XXXX, "trace_id": "XXXX", "metrics": {"_dd.measured": 1}, "parent_id": "XXXX", "meta": {"http.status_code": "200", "http.url": "https://ip-ranges.datadoghq.eu/", "_dd.origin": "lambda", "http.method": "GET"}, "error": 0, "duration": XXXX, "type": "http", "span_id": "XXXX"}, {"resource": "requests.request", "name": "requests.request", "service": "aws.lambda", "start": XXXX, "trace_id": "XXXX", "metrics": {"_dd.measured": 1}, "parent_id": "XXXX", "meta": {"http.status_code": "202", "http.url": "https://api.datadoghq.com/api/v1/distribution_points", "_dd.origin": "lambda", "http.method": "POST"}, "error": 0, "duration": XXXX, "type": "http", "span_id": "XXXX"}]]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true datadog-lambda-python-18/tests/integration/snapshots/logs/http-requests_python36.log000066400000000000000000000246651366355203100312450ustar00rootroot00000000000000START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-http-requests_python36", "cold_start:true", "memorysize:1024", "runtime:python3.6", "dd_lambda_layer:datadog-python36_2.XX.0"]} HTTP GET https://ip-ranges.datadoghq.com/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP GET https://ip-ranges.datadoghq.eu/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"], "interval": 10}]} {"traces": [[{"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "integration-tester-dev-http-requests_python36", "name": "aws.lambda", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "cold_start": "true", "function_arn": "arn:aws:lambda:us-east-1:601427279990:function:integration-tester-dev-http-requests_python36", "request_id": "XXXX", "resource_names": "integration-tester-dev-http-requests_python36", "_dd.parent_source": "xray"}, "metrics": {"_dd.agent_psr": 1.0, "system.pid": XXXX, "_sampling_priority_v1": 1}, "type": "serverless"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.com/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.eu/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "POST", "http.url": "https://api.datadoghq.com/api/v1/distribution_points", "http.status_code": "202"}, "metrics": {"_dd.measured": 1}, "type": "http"}]]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB Init Duration: XXXX ms XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-http-requests_python36", "cold_start:false", "memorysize:1024", "runtime:python3.6", "dd_lambda_layer:datadog-python36_2.XX.0"]} HTTP GET https://ip-ranges.datadoghq.com/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP GET https://ip-ranges.datadoghq.eu/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"], "interval": 10}]} {"traces": [[{"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "integration-tester-dev-http-requests_python36", "name": "aws.lambda", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "cold_start": "false", "function_arn": "arn:aws:lambda:us-east-1:601427279990:function:integration-tester-dev-http-requests_python36", "request_id": "XXXX", "resource_names": "integration-tester-dev-http-requests_python36", "_dd.parent_source": "xray"}, "metrics": {"_dd.agent_psr": 1.0, "system.pid": XXXX, "_sampling_priority_v1": 1}, "type": "serverless"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.com/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.eu/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "POST", "http.url": "https://api.datadoghq.com/api/v1/distribution_points", "http.status_code": "202"}, "metrics": {"_dd.measured": 1}, "type": "http"}]]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-http-requests_python36", "cold_start:false", "memorysize:1024", "runtime:python3.6", "dd_lambda_layer:datadog-python36_2.XX.0"]} HTTP GET https://ip-ranges.datadoghq.com/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP GET https://ip-ranges.datadoghq.eu/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"], "interval": 10}]} {"traces": [[{"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "integration-tester-dev-http-requests_python36", "name": "aws.lambda", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "cold_start": "false", "function_arn": "arn:aws:lambda:us-east-1:601427279990:function:integration-tester-dev-http-requests_python36", "request_id": "XXXX", "resource_names": "integration-tester-dev-http-requests_python36", "_dd.parent_source": "xray"}, "metrics": {"_dd.agent_psr": 1.0, "system.pid": XXXX, "_sampling_priority_v1": 1}, "type": "serverless"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.com/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.eu/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "POST", "http.url": "https://api.datadoghq.com/api/v1/distribution_points", "http.status_code": "202"}, "metrics": {"_dd.measured": 1}, "type": "http"}]]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true datadog-lambda-python-18/tests/integration/snapshots/logs/http-requests_python37.log000066400000000000000000000246651366355203100312460ustar00rootroot00000000000000START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-http-requests_python37", "cold_start:true", "memorysize:1024", "runtime:python3.7", "dd_lambda_layer:datadog-python37_2.XX.0"]} HTTP GET https://ip-ranges.datadoghq.com/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP GET https://ip-ranges.datadoghq.eu/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"], "interval": 10}]} {"traces": [[{"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "integration-tester-dev-http-requests_python37", "name": "aws.lambda", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "cold_start": "true", "function_arn": "arn:aws:lambda:us-east-1:601427279990:function:integration-tester-dev-http-requests_python37", "request_id": "XXXX", "resource_names": "integration-tester-dev-http-requests_python37", "_dd.parent_source": "xray"}, "metrics": {"_dd.agent_psr": 1.0, "system.pid": XXXX, "_sampling_priority_v1": 1}, "type": "serverless"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.com/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.eu/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "POST", "http.url": "https://api.datadoghq.com/api/v1/distribution_points", "http.status_code": "202"}, "metrics": {"_dd.measured": 1}, "type": "http"}]]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB Init Duration: XXXX ms XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-http-requests_python37", "cold_start:false", "memorysize:1024", "runtime:python3.7", "dd_lambda_layer:datadog-python37_2.XX.0"]} HTTP GET https://ip-ranges.datadoghq.com/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP GET https://ip-ranges.datadoghq.eu/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"], "interval": 10}]} {"traces": [[{"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "integration-tester-dev-http-requests_python37", "name": "aws.lambda", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "cold_start": "false", "function_arn": "arn:aws:lambda:us-east-1:601427279990:function:integration-tester-dev-http-requests_python37", "request_id": "XXXX", "resource_names": "integration-tester-dev-http-requests_python37", "_dd.parent_source": "xray"}, "metrics": {"_dd.agent_psr": 1.0, "system.pid": XXXX, "_sampling_priority_v1": 1}, "type": "serverless"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.com/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.eu/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "POST", "http.url": "https://api.datadoghq.com/api/v1/distribution_points", "http.status_code": "202"}, "metrics": {"_dd.measured": 1}, "type": "http"}]]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-http-requests_python37", "cold_start:false", "memorysize:1024", "runtime:python3.7", "dd_lambda_layer:datadog-python37_2.XX.0"]} HTTP GET https://ip-ranges.datadoghq.com/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP GET https://ip-ranges.datadoghq.eu/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"], "interval": 10}]} {"traces": [[{"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "integration-tester-dev-http-requests_python37", "name": "aws.lambda", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "cold_start": "false", "function_arn": "arn:aws:lambda:us-east-1:601427279990:function:integration-tester-dev-http-requests_python37", "request_id": "XXXX", "resource_names": "integration-tester-dev-http-requests_python37", "_dd.parent_source": "xray"}, "metrics": {"_dd.agent_psr": 1.0, "system.pid": XXXX, "_sampling_priority_v1": 1}, "type": "serverless"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.com/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.eu/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "POST", "http.url": "https://api.datadoghq.com/api/v1/distribution_points", "http.status_code": "202"}, "metrics": {"_dd.measured": 1}, "type": "http"}]]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true datadog-lambda-python-18/tests/integration/snapshots/logs/http-requests_python38.log000066400000000000000000000246651366355203100312470ustar00rootroot00000000000000START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-http-requests_python38", "cold_start:true", "memorysize:1024", "runtime:python3.8", "dd_lambda_layer:datadog-python38_2.XX.0"]} HTTP GET https://ip-ranges.datadoghq.com/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP GET https://ip-ranges.datadoghq.eu/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"], "interval": 10}]} {"traces": [[{"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "integration-tester-dev-http-requests_python38", "name": "aws.lambda", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "cold_start": "true", "function_arn": "arn:aws:lambda:us-east-1:601427279990:function:integration-tester-dev-http-requests_python38", "request_id": "XXXX", "resource_names": "integration-tester-dev-http-requests_python38", "_dd.parent_source": "xray"}, "metrics": {"_dd.agent_psr": 1.0, "system.pid": XXXX, "_sampling_priority_v1": 1}, "type": "serverless"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.com/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.eu/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "POST", "http.url": "https://api.datadoghq.com/api/v1/distribution_points", "http.status_code": "202"}, "metrics": {"_dd.measured": 1}, "type": "http"}]]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB Init Duration: XXXX ms XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-http-requests_python38", "cold_start:false", "memorysize:1024", "runtime:python3.8", "dd_lambda_layer:datadog-python38_2.XX.0"]} HTTP GET https://ip-ranges.datadoghq.com/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP GET https://ip-ranges.datadoghq.eu/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"], "interval": 10}]} {"traces": [[{"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "integration-tester-dev-http-requests_python38", "name": "aws.lambda", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "cold_start": "false", "function_arn": "arn:aws:lambda:us-east-1:601427279990:function:integration-tester-dev-http-requests_python38", "request_id": "XXXX", "resource_names": "integration-tester-dev-http-requests_python38", "_dd.parent_source": "xray"}, "metrics": {"_dd.agent_psr": 1.0, "system.pid": XXXX, "_sampling_priority_v1": 1}, "type": "serverless"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.com/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.eu/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "POST", "http.url": "https://api.datadoghq.com/api/v1/distribution_points", "http.status_code": "202"}, "metrics": {"_dd.measured": 1}, "type": "http"}]]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-http-requests_python38", "cold_start:false", "memorysize:1024", "runtime:python3.8", "dd_lambda_layer:datadog-python38_2.XX.0"]} HTTP GET https://ip-ranges.datadoghq.com/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP GET https://ip-ranges.datadoghq.eu/ Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:1", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"], "interval": 10}]} {"traces": [[{"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "integration-tester-dev-http-requests_python38", "name": "aws.lambda", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "cold_start": "false", "function_arn": "arn:aws:lambda:us-east-1:601427279990:function:integration-tester-dev-http-requests_python38", "request_id": "XXXX", "resource_names": "integration-tester-dev-http-requests_python38", "_dd.parent_source": "xray"}, "metrics": {"_dd.agent_psr": 1.0, "system.pid": XXXX, "_sampling_priority_v1": 1}, "type": "serverless"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.com/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "GET", "http.url": "https://ip-ranges.datadoghq.eu/", "http.status_code": "200"}, "metrics": {"_dd.measured": 1}, "type": "http"}, {"trace_id": "XXXX", "parent_id": "XXXX", "span_id": "XXXX", "service": "aws.lambda", "resource": "requests.request", "name": "requests.request", "error": 0, "start": XXXX, "duration": XXXX, "meta": {"_dd.origin": "lambda", "http.method": "POST", "http.url": "https://api.datadoghq.com/api/v1/distribution_points", "http.status_code": "202"}, "metrics": {"_dd.measured": 1}, "type": "http"}]]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true datadog-lambda-python-18/tests/integration/snapshots/logs/sync-metrics_python27.log000066400000000000000000000074311366355203100310250ustar00rootroot00000000000000START RequestId: XXXX Version: $LATEST {"e": XXXX, "m": "aws.lambda.enhanced.invocations", "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-sync-metrics_python27", "cold_start:true", "memorysize:1024", "runtime:python2.7", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 1} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:2", "x-datadog-trace-id:XXXX"] Data: {"series": [{"tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "metric": "hello.dog", "interval": 10, "host": null, "points": [[XXXX, [1.0]]], "device": null, "type": "distribution"}, {"tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "metric": "tests.integration.count", "interval": 10, "host": null, "points": [[XXXX, [21.0]]], "device": null, "type": "distribution"}]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB Init Duration: XXXX ms XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"e": XXXX, "m": "aws.lambda.enhanced.invocations", "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-sync-metrics_python27", "cold_start:false", "memorysize:1024", "runtime:python2.7", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 1} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:2", "x-datadog-trace-id:XXXX"] Data: {"series": [{"tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "metric": "hello.dog", "interval": 10, "host": null, "points": [[XXXX, [1.0]]], "device": null, "type": "distribution"}, {"tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "metric": "tests.integration.count", "interval": 10, "host": null, "points": [[XXXX, [21.0]]], "device": null, "type": "distribution"}]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"e": XXXX, "m": "aws.lambda.enhanced.invocations", "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-sync-metrics_python27", "cold_start:false", "memorysize:1024", "runtime:python2.7", "dd_lambda_layer:datadog-python27_2.XX.0"], "v": 1} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:2", "x-datadog-trace-id:XXXX"] Data: {"series": [{"tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "metric": "hello.dog", "interval": 10, "host": null, "points": [[XXXX, [1.0]]], "device": null, "type": "distribution"}, {"tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python27_2.XX.0"], "metric": "tests.integration.count", "interval": 10, "host": null, "points": [[XXXX, [21.0]]], "device": null, "type": "distribution"}]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true datadog-lambda-python-18/tests/integration/snapshots/logs/sync-metrics_python36.log000066400000000000000000000074311366355203100310250ustar00rootroot00000000000000START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-sync-metrics_python36", "cold_start:true", "memorysize:1024", "runtime:python3.6", "dd_lambda_layer:datadog-python36_2.XX.0"]} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:2", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"], "interval": 10}]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB Init Duration: XXXX ms XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-sync-metrics_python36", "cold_start:false", "memorysize:1024", "runtime:python3.6", "dd_lambda_layer:datadog-python36_2.XX.0"]} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:2", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"], "interval": 10}]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-sync-metrics_python36", "cold_start:false", "memorysize:1024", "runtime:python3.6", "dd_lambda_layer:datadog-python36_2.XX.0"]} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:2", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python36_2.XX.0"], "interval": 10}]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true datadog-lambda-python-18/tests/integration/snapshots/logs/sync-metrics_python37.log000066400000000000000000000074311366355203100310260ustar00rootroot00000000000000START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-sync-metrics_python37", "cold_start:true", "memorysize:1024", "runtime:python3.7", "dd_lambda_layer:datadog-python37_2.XX.0"]} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:2", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"], "interval": 10}]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB Init Duration: XXXX ms XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-sync-metrics_python37", "cold_start:false", "memorysize:1024", "runtime:python3.7", "dd_lambda_layer:datadog-python37_2.XX.0"]} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:2", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"], "interval": 10}]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-sync-metrics_python37", "cold_start:false", "memorysize:1024", "runtime:python3.7", "dd_lambda_layer:datadog-python37_2.XX.0"]} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:2", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python37_2.XX.0"], "interval": 10}]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true datadog-lambda-python-18/tests/integration/snapshots/logs/sync-metrics_python38.log000066400000000000000000000074311366355203100310270ustar00rootroot00000000000000START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-sync-metrics_python38", "cold_start:true", "memorysize:1024", "runtime:python3.8", "dd_lambda_layer:datadog-python38_2.XX.0"]} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:2", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"], "interval": 10}]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB Init Duration: XXXX ms XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-sync-metrics_python38", "cold_start:false", "memorysize:1024", "runtime:python3.8", "dd_lambda_layer:datadog-python38_2.XX.0"]} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:2", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"], "interval": 10}]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true START RequestId: XXXX Version: $LATEST {"m": "aws.lambda.enhanced.invocations", "v": 1, "e": XXXX, "t": ["region:us-east-1", "account_id:XXXX", "functionname:integration-tester-dev-sync-metrics_python38", "cold_start:false", "memorysize:1024", "runtime:python3.8", "dd_lambda_layer:datadog-python38_2.XX.0"]} HTTP POST https://api.datadoghq.com/api/v1/distribution_points?api_key=XXXX Headers: ["Accept-Encoding:gzip, deflate", "Accept:*/*", "Connection:keep-alive", "Content-Length:460", "Content-Type:application/json", "User-Agent:python-requests/2.23.0", "x-datadog-parent-id:XXXX", "x-datadog-sampling-priority:2", "x-datadog-trace-id:XXXX"] Data: {"series": [{"metric": "hello.dog", "points": [[XXXX, [1.0]]], "type": "distribution", "host": null, "device": null, "tags": ["team:serverless", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"], "interval": 10}, {"metric": "tests.integration.count", "points": [[XXXX, [21.0]]], "type": "distribution", "host": null, "device": null, "tags": ["test:integration", "role:hello", "dd_lambda_layer:datadog-python38_2.XX.0"], "interval": 10}]} END RequestId: XXXX REPORT RequestId: XXXX Duration: XXXX ms Billed Duration: XXXX ms Memory Size: 1024 MB Max Memory Used: XXXX MB XRAY TraceId: XXXX SegmentId: XXXX Sampled: true datadog-lambda-python-18/tests/integration/snapshots/return_values/000077500000000000000000000000001366355203100260555ustar00rootroot00000000000000async-metrics_python27_api-gateway-get.json000066400000000000000000000002561366355203100362740ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/return_values{ "body": { "message": "hello, dog!", "event_record_ids": [], "request_id": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9" }, "statusCode": 200 } datadog-lambda-python-18/tests/integration/snapshots/return_values/async-metrics_python27_sns.json000066400000000000000000000003101366355203100341600ustar00rootroot00000000000000{ "body": { "message": "hello, dog!", "event_record_ids": [ "95df01b4-ee98-5cb9-9903-4c221d41eb5e" ], "request_id": null }, "statusCode": 200 } datadog-lambda-python-18/tests/integration/snapshots/return_values/async-metrics_python27_sqs.json000066400000000000000000000003741366355203100341750ustar00rootroot00000000000000{ "body": { "message": "hello, dog!", "event_record_ids": [ "059f36b4-87a3-44ab-83d2-661975830a7d", "2e1424d4-f796-459a-8184-9c92662be6da" ], "request_id": null }, "statusCode": 200 } async-metrics_python36_api-gateway-get.json000066400000000000000000000002561366355203100362740ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/return_values{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9", "event_record_ids": [] } } datadog-lambda-python-18/tests/integration/snapshots/return_values/async-metrics_python36_sns.json000066400000000000000000000003101366355203100341600ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": null, "event_record_ids": [ "95df01b4-ee98-5cb9-9903-4c221d41eb5e" ] } } datadog-lambda-python-18/tests/integration/snapshots/return_values/async-metrics_python36_sqs.json000066400000000000000000000003741366355203100341750ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": null, "event_record_ids": [ "059f36b4-87a3-44ab-83d2-661975830a7d", "2e1424d4-f796-459a-8184-9c92662be6da" ] } } async-metrics_python37_api-gateway-get.json000066400000000000000000000002561366355203100362750ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/return_values{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9", "event_record_ids": [] } } datadog-lambda-python-18/tests/integration/snapshots/return_values/async-metrics_python37_sns.json000066400000000000000000000003101366355203100341610ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": null, "event_record_ids": [ "95df01b4-ee98-5cb9-9903-4c221d41eb5e" ] } } datadog-lambda-python-18/tests/integration/snapshots/return_values/async-metrics_python37_sqs.json000066400000000000000000000003741366355203100341760ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": null, "event_record_ids": [ "059f36b4-87a3-44ab-83d2-661975830a7d", "2e1424d4-f796-459a-8184-9c92662be6da" ] } } async-metrics_python38_api-gateway-get.json000066400000000000000000000002561366355203100362760ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/return_values{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9", "event_record_ids": [] } } datadog-lambda-python-18/tests/integration/snapshots/return_values/async-metrics_python38_sns.json000066400000000000000000000003101366355203100341620ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": null, "event_record_ids": [ "95df01b4-ee98-5cb9-9903-4c221d41eb5e" ] } } datadog-lambda-python-18/tests/integration/snapshots/return_values/async-metrics_python38_sqs.json000066400000000000000000000003741366355203100341770ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": null, "event_record_ids": [ "059f36b4-87a3-44ab-83d2-661975830a7d", "2e1424d4-f796-459a-8184-9c92662be6da" ] } } http-requests_python27_api-gateway-get.json000066400000000000000000000001201366355203100363310ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/return_values{ "body": { "message": "hello, dog!" }, "statusCode": 200 } datadog-lambda-python-18/tests/integration/snapshots/return_values/http-requests_python27_sns.json000066400000000000000000000001201366355203100342260ustar00rootroot00000000000000{ "body": { "message": "hello, dog!" }, "statusCode": 200 } datadog-lambda-python-18/tests/integration/snapshots/return_values/http-requests_python27_sqs.json000066400000000000000000000001201366355203100342310ustar00rootroot00000000000000{ "body": { "message": "hello, dog!" }, "statusCode": 200 } http-requests_python36_api-gateway-get.json000066400000000000000000000001201366355203100363310ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/return_values{ "statusCode": 200, "body": { "message": "hello, dog!" } } datadog-lambda-python-18/tests/integration/snapshots/return_values/http-requests_python36_sns.json000066400000000000000000000001201366355203100342260ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!" } } datadog-lambda-python-18/tests/integration/snapshots/return_values/http-requests_python36_sqs.json000066400000000000000000000001201366355203100342310ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!" } } http-requests_python37_api-gateway-get.json000066400000000000000000000001201366355203100363320ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/return_values{ "statusCode": 200, "body": { "message": "hello, dog!" } } datadog-lambda-python-18/tests/integration/snapshots/return_values/http-requests_python37_sns.json000066400000000000000000000001201366355203100342270ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!" } } datadog-lambda-python-18/tests/integration/snapshots/return_values/http-requests_python37_sqs.json000066400000000000000000000001201366355203100342320ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!" } } http-requests_python38_api-gateway-get.json000066400000000000000000000001201366355203100363330ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/return_values{ "statusCode": 200, "body": { "message": "hello, dog!" } } datadog-lambda-python-18/tests/integration/snapshots/return_values/http-requests_python38_sns.json000066400000000000000000000001201366355203100342300ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!" } } datadog-lambda-python-18/tests/integration/snapshots/return_values/http-requests_python38_sqs.json000066400000000000000000000001201366355203100342330ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!" } } sync-metrics_python27_api-gateway-get.json000066400000000000000000000002561366355203100361330ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/return_values{ "body": { "message": "hello, dog!", "event_record_ids": [], "request_id": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9" }, "statusCode": 200 } datadog-lambda-python-18/tests/integration/snapshots/return_values/sync-metrics_python27_sns.json000066400000000000000000000003101366355203100340170ustar00rootroot00000000000000{ "body": { "message": "hello, dog!", "event_record_ids": [ "95df01b4-ee98-5cb9-9903-4c221d41eb5e" ], "request_id": null }, "statusCode": 200 } datadog-lambda-python-18/tests/integration/snapshots/return_values/sync-metrics_python27_sqs.json000066400000000000000000000003741366355203100340340ustar00rootroot00000000000000{ "body": { "message": "hello, dog!", "event_record_ids": [ "059f36b4-87a3-44ab-83d2-661975830a7d", "2e1424d4-f796-459a-8184-9c92662be6da" ], "request_id": null }, "statusCode": 200 } sync-metrics_python36_api-gateway-get.json000066400000000000000000000002561366355203100361330ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/return_values{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9", "event_record_ids": [] } } datadog-lambda-python-18/tests/integration/snapshots/return_values/sync-metrics_python36_sns.json000066400000000000000000000003101366355203100340170ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": null, "event_record_ids": [ "95df01b4-ee98-5cb9-9903-4c221d41eb5e" ] } } datadog-lambda-python-18/tests/integration/snapshots/return_values/sync-metrics_python36_sqs.json000066400000000000000000000003741366355203100340340ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": null, "event_record_ids": [ "059f36b4-87a3-44ab-83d2-661975830a7d", "2e1424d4-f796-459a-8184-9c92662be6da" ] } } sync-metrics_python37_api-gateway-get.json000066400000000000000000000002561366355203100361340ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/return_values{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9", "event_record_ids": [] } } datadog-lambda-python-18/tests/integration/snapshots/return_values/sync-metrics_python37_sns.json000066400000000000000000000003101366355203100340200ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": null, "event_record_ids": [ "95df01b4-ee98-5cb9-9903-4c221d41eb5e" ] } } datadog-lambda-python-18/tests/integration/snapshots/return_values/sync-metrics_python37_sqs.json000066400000000000000000000003741366355203100340350ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": null, "event_record_ids": [ "059f36b4-87a3-44ab-83d2-661975830a7d", "2e1424d4-f796-459a-8184-9c92662be6da" ] } } sync-metrics_python38_api-gateway-get.json000066400000000000000000000002561366355203100361350ustar00rootroot00000000000000datadog-lambda-python-18/tests/integration/snapshots/return_values{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9", "event_record_ids": [] } } datadog-lambda-python-18/tests/integration/snapshots/return_values/sync-metrics_python38_sns.json000066400000000000000000000003101366355203100340210ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": null, "event_record_ids": [ "95df01b4-ee98-5cb9-9903-4c221d41eb5e" ] } } datadog-lambda-python-18/tests/integration/snapshots/return_values/sync-metrics_python38_sqs.json000066400000000000000000000003741366355203100340360ustar00rootroot00000000000000{ "statusCode": 200, "body": { "message": "hello, dog!", "request_id": null, "event_record_ids": [ "059f36b4-87a3-44ab-83d2-661975830a7d", "2e1424d4-f796-459a-8184-9c92662be6da" ] } } datadog-lambda-python-18/tests/test_metric.py000066400000000000000000000023721366355203100215120ustar00rootroot00000000000000import os import unittest try: from unittest.mock import patch, call except ImportError: from mock import patch, call from datadog_lambda.metric import lambda_metric from datadog_lambda.tags import _format_dd_lambda_layer_tag class TestLambdaMetric(unittest.TestCase): def setUp(self): patcher = patch("datadog_lambda.metric.lambda_stats") self.mock_metric_lambda_stats = patcher.start() self.addCleanup(patcher.stop) def test_lambda_metric_tagged_with_dd_lambda_layer(self): lambda_metric("test", 1) lambda_metric("test", 1, 123, []) lambda_metric("test", 1, tags=["tag1:test"]) expected_tag = _format_dd_lambda_layer_tag() self.mock_metric_lambda_stats.distribution.assert_has_calls( [ call("test", 1, timestamp=None, tags=[expected_tag]), call("test", 1, timestamp=123, tags=[expected_tag]), call("test", 1, timestamp=None, tags=["tag1:test", expected_tag]), ] ) def test_lambda_metric_flush_to_log(self): os.environ["DD_FLUSH_TO_LOG"] = "True" lambda_metric("test", 1) self.mock_metric_lambda_stats.distribution.assert_not_called() del os.environ["DD_FLUSH_TO_LOG"] datadog-lambda-python-18/tests/test_patch.py000066400000000000000000000071651366355203100213330ustar00rootroot00000000000000import sys import unittest try: from unittest.mock import patch, MagicMock except ImportError: from mock import patch, MagicMock from datadog_lambda.patch import _patch_httplib, _ensure_patch_requests from datadog_lambda.constants import TraceHeader class TestPatchHTTPClients(unittest.TestCase): def setUp(self): patcher = patch("datadog_lambda.patch.get_dd_trace_context") self.mock_get_dd_trace_context = patcher.start() self.mock_get_dd_trace_context.return_value = { TraceHeader.TRACE_ID: "123", TraceHeader.PARENT_ID: "321", TraceHeader.SAMPLING_PRIORITY: "2", } self.addCleanup(patcher.stop) def test_patch_httplib(self): _patch_httplib() if sys.version_info >= (3, 0, 0): from http.client import HTTPSConnection else: from httplib import HTTPSConnection conn = HTTPSConnection("www.datadoghq.com") conn.request("GET", "/") conn.getresponse() self.mock_get_dd_trace_context.assert_called() def test_patch_httplib_dict_headers(self): _patch_httplib() if sys.version_info >= (3, 0, 0): from http.client import HTTPSConnection else: from httplib import HTTPSConnection headers = MagicMock(spec=dict) headers["fake-header"] = "fake-value" conn = HTTPSConnection("www.datadoghq.com") conn.request("GET", "/", headers=headers) conn.getresponse() self.mock_get_dd_trace_context.assert_called() headers.update.assert_called() def test_patch_httplib_dict_like_headers(self): _patch_httplib() if sys.version_info >= (3, 0, 0): from http.client import HTTPSConnection from collections.abc import MutableMapping else: from httplib import HTTPSConnection from collections import MutableMapping headers = MagicMock(spec=MutableMapping) headers["fake-header"] = "fake-value" conn = HTTPSConnection("www.datadoghq.com") conn.request("GET", "/", headers=headers) conn.getresponse() self.mock_get_dd_trace_context.assert_called() headers.update.assert_called() def test_patch_requests(self): _ensure_patch_requests() import requests r = requests.get("https://www.datadoghq.com/") self.mock_get_dd_trace_context.assert_called() self.assertEqual(r.request.headers[TraceHeader.TRACE_ID], "123") self.assertEqual(r.request.headers[TraceHeader.PARENT_ID], "321") self.assertEqual(r.request.headers[TraceHeader.SAMPLING_PRIORITY], "2") def test_patch_requests_with_headers(self): _ensure_patch_requests() import requests r = requests.get("https://www.datadoghq.com/", headers={"key": "value"}) self.mock_get_dd_trace_context.assert_called() self.assertEqual(r.request.headers["key"], "value") self.assertEqual(r.request.headers[TraceHeader.TRACE_ID], "123") self.assertEqual(r.request.headers[TraceHeader.PARENT_ID], "321") self.assertEqual(r.request.headers[TraceHeader.SAMPLING_PRIORITY], "2") def test_patch_requests_with_headers_none(self): _ensure_patch_requests() import requests r = requests.get("https://www.datadoghq.com/", headers=None) self.mock_get_dd_trace_context.assert_called() self.assertEqual(r.request.headers[TraceHeader.TRACE_ID], "123") self.assertEqual(r.request.headers[TraceHeader.PARENT_ID], "321") self.assertEqual(r.request.headers[TraceHeader.SAMPLING_PRIORITY], "2") datadog-lambda-python-18/tests/test_tags.py000066400000000000000000000026461366355203100211710ustar00rootroot00000000000000import unittest try: from unittest.mock import patch except ImportError: from mock import patch from datadog_lambda.tags import parse_lambda_tags_from_arn, get_runtime_tag class TestMetricTags(unittest.TestCase): def setUp(self): patcher = patch("datadog_lambda.tags.python_version_tuple") self.mock_python_version_tuple = patcher.start() self.addCleanup(patcher.stop) def test_parse_lambda_tags_from_arn(self): self.assertListEqual( parse_lambda_tags_from_arn( "arn:aws:lambda:us-east-1:1234597598159:function:swf-hello-test" ), [ "region:us-east-1", "account_id:1234597598159", "functionname:swf-hello-test", ], ) self.assertListEqual( parse_lambda_tags_from_arn( "arn:aws:lambda:us-west-1:1234597598159:function:other-function:function-alias" ), [ "region:us-west-1", "account_id:1234597598159", "functionname:other-function", ], ) def test_get_runtime_tag(self): self.mock_python_version_tuple.return_value = ("2", "7", "10") self.assertEqual(get_runtime_tag(), "runtime:python2.7") self.mock_python_version_tuple.return_value = ("3", "7", "2") self.assertEqual(get_runtime_tag(), "runtime:python3.7") datadog-lambda-python-18/tests/test_tracing.py000066400000000000000000000143341366355203100216570ustar00rootroot00000000000000import unittest try: from unittest.mock import MagicMock, patch except ImportError: from mock import MagicMock, patch from ddtrace.helpers import get_correlation_ids from datadog_lambda.constants import SamplingPriority, TraceHeader, XraySubsegment from datadog_lambda.tracing import ( extract_dd_trace_context, get_dd_trace_context, set_correlation_ids, _convert_xray_trace_id, _convert_xray_entity_id, _convert_xray_sampling, ) class TestExtractAndGetDDTraceContext(unittest.TestCase): def setUp(self): global dd_tracing_enabled dd_tracing_enabled = False patcher = patch("datadog_lambda.tracing.xray_recorder") self.mock_xray_recorder = patcher.start() self.mock_xray_recorder.get_trace_entity.return_value = MagicMock( id="ffff", trace_id="1111", sampled=True ) self.mock_current_subsegment = MagicMock() self.mock_xray_recorder.current_subsegment.return_value = ( self.mock_current_subsegment ) self.addCleanup(patcher.stop) patcher = patch("datadog_lambda.tracing.is_lambda_context") self.mock_is_lambda_context = patcher.start() self.mock_is_lambda_context.return_value = True self.addCleanup(patcher.stop) def tearDown(self): global dd_tracing_enabled dd_tracing_enabled = False def test_without_datadog_trace_headers(self): ctx = extract_dd_trace_context({}) self.assertDictEqual( ctx, { "trace-id": "4369", "parent-id": "65535", "sampling-priority": "2", "source": "xray", }, ) self.assertDictEqual( get_dd_trace_context(), { TraceHeader.TRACE_ID: "4369", TraceHeader.PARENT_ID: "65535", TraceHeader.SAMPLING_PRIORITY: "2", }, ) def test_with_incomplete_datadog_trace_headers(self): ctx = extract_dd_trace_context( {"headers": {TraceHeader.TRACE_ID: "123", TraceHeader.PARENT_ID: "321"}} ) self.assertDictEqual( ctx, { "trace-id": "4369", "parent-id": "65535", "sampling-priority": "2", "source": "xray", }, ) self.assertDictEqual( get_dd_trace_context(), { TraceHeader.TRACE_ID: "4369", TraceHeader.PARENT_ID: "65535", TraceHeader.SAMPLING_PRIORITY: "2", }, ) def test_with_complete_datadog_trace_headers(self): ctx = extract_dd_trace_context( { "headers": { TraceHeader.TRACE_ID: "123", TraceHeader.PARENT_ID: "321", TraceHeader.SAMPLING_PRIORITY: "1", } } ) self.assertDictEqual( ctx, { "trace-id": "123", "parent-id": "321", "sampling-priority": "1", "source": "event", }, ) self.assertDictEqual( get_dd_trace_context(), { TraceHeader.TRACE_ID: "123", TraceHeader.PARENT_ID: "65535", TraceHeader.SAMPLING_PRIORITY: "1", }, ) self.mock_xray_recorder.begin_subsegment.assert_called() self.mock_xray_recorder.end_subsegment.assert_called() self.mock_current_subsegment.put_metadata.assert_called_with( XraySubsegment.KEY, {"trace-id": "123", "parent-id": "321", "sampling-priority": "1"}, XraySubsegment.NAMESPACE, ) def test_with_complete_datadog_trace_headers_with_mixed_casing(self): extract_dd_trace_context( { "headers": { "X-Datadog-Trace-Id": "123", "X-Datadog-Parent-Id": "321", "X-Datadog-Sampling-Priority": "1", } } ) self.assertDictEqual( get_dd_trace_context(), { TraceHeader.TRACE_ID: "123", TraceHeader.PARENT_ID: "65535", TraceHeader.SAMPLING_PRIORITY: "1", }, ) class TestXRayContextConversion(unittest.TestCase): def test_convert_xray_trace_id(self): self.assertEqual( _convert_xray_trace_id("00000000e1be46a994272793"), "7043144561403045779" ) self.assertEqual( _convert_xray_trace_id("bd862e3fe1be46a994272793"), "7043144561403045779" ) self.assertEqual( _convert_xray_trace_id("ffffffffffffffffffffffff"), "9223372036854775807", # 0x7FFFFFFFFFFFFFFF ) def test_convert_xray_entity_id(self): self.assertEqual( _convert_xray_entity_id("53995c3f42cd8ad8"), "6023947403358210776" ) self.assertEqual( _convert_xray_entity_id("1000000000000000"), "1152921504606846976" ) self.assertEqual( _convert_xray_entity_id("ffffffffffffffff"), "18446744073709551615" ) def test_convert_xray_sampling(self): self.assertEqual(_convert_xray_sampling(True), str(SamplingPriority.USER_KEEP)) self.assertEqual( _convert_xray_sampling(False), str(SamplingPriority.USER_REJECT) ) class TestLogsInjection(unittest.TestCase): def setUp(self): patcher = patch("datadog_lambda.tracing.get_dd_trace_context") self.mock_get_dd_trace_context = patcher.start() self.mock_get_dd_trace_context.return_value = { TraceHeader.TRACE_ID: "123", TraceHeader.PARENT_ID: "456", } self.addCleanup(patcher.stop) patcher = patch("datadog_lambda.tracing.is_lambda_context") self.mock_is_lambda_context = patcher.start() self.mock_is_lambda_context.return_value = True self.addCleanup(patcher.stop) def test_set_correlation_ids(self): set_correlation_ids() trace_id, span_id = get_correlation_ids() self.assertEqual(trace_id, "123") self.assertEqual(span_id, "456") datadog-lambda-python-18/tests/test_wrapper.py000066400000000000000000000232771366355203100217160ustar00rootroot00000000000000import os import unittest try: from unittest.mock import patch, call, ANY, MagicMock except ImportError: from mock import patch, call, ANY, MagicMock from datadog_lambda.wrapper import datadog_lambda_wrapper from datadog_lambda.metric import lambda_metric def get_mock_context( aws_request_id="request-id-1", memory_limit_in_mb="256", invoked_function_arn="arn:aws:lambda:us-west-1:123457598159:function:python-layer-test", ): lambda_context = MagicMock() lambda_context.aws_request_id = aws_request_id lambda_context.memory_limit_in_mb = memory_limit_in_mb lambda_context.invoked_function_arn = invoked_function_arn return lambda_context class TestDatadogLambdaWrapper(unittest.TestCase): def setUp(self): # Force @datadog_lambda_wrapper to always create a real # (not no-op) wrapper. datadog_lambda_wrapper._force_wrap = True patcher = patch("datadog_lambda.metric.lambda_stats") self.mock_metric_lambda_stats = patcher.start() self.addCleanup(patcher.stop) patcher = patch("datadog_lambda.wrapper.lambda_stats") self.mock_wrapper_lambda_stats = patcher.start() self.addCleanup(patcher.stop) patcher = patch("datadog_lambda.metric.lambda_metric") self.mock_lambda_metric = patcher.start() self.addCleanup(patcher.stop) patcher = patch("datadog_lambda.wrapper.extract_dd_trace_context") self.mock_extract_dd_trace_context = patcher.start() self.addCleanup(patcher.stop) patcher = patch("datadog_lambda.wrapper.set_correlation_ids") self.mock_set_correlation_ids = patcher.start() self.addCleanup(patcher.stop) patcher = patch("datadog_lambda.wrapper.inject_correlation_ids") self.mock_inject_correlation_ids = patcher.start() self.addCleanup(patcher.stop) patcher = patch("datadog_lambda.wrapper.patch_all") self.mock_patch_all = patcher.start() self.addCleanup(patcher.stop) patcher = patch("datadog_lambda.cold_start.is_cold_start") self.mock_is_cold_start = patcher.start() self.mock_is_cold_start.return_value = True self.addCleanup(patcher.stop) patcher = patch("datadog_lambda.tags.python_version_tuple") self.mock_python_version_tuple = patcher.start() self.mock_python_version_tuple.return_value = ("2", "7", "10") self.addCleanup(patcher.stop) patcher = patch("datadog_lambda.metric.write_metric_point_to_stdout") self.mock_write_metric_point_to_stdout = patcher.start() self.addCleanup(patcher.stop) patcher = patch("datadog_lambda.tags._format_dd_lambda_layer_tag") self.mock_format_dd_lambda_layer_tag = patcher.start() # Mock the layer version so we don't have to update tests on every version bump self.mock_format_dd_lambda_layer_tag.return_value = ( "dd_lambda_layer:datadog-python27_0.1.0" ) self.addCleanup(patcher.stop) def test_datadog_lambda_wrapper(self): @datadog_lambda_wrapper def lambda_handler(event, context): lambda_metric("test.metric", 100) lambda_event = {} lambda_handler(lambda_event, get_mock_context()) self.mock_metric_lambda_stats.distribution.assert_has_calls( [call("test.metric", 100, timestamp=None, tags=ANY)] ) self.mock_wrapper_lambda_stats.flush.assert_called() self.mock_extract_dd_trace_context.assert_called_with(lambda_event) self.mock_set_correlation_ids.assert_called() self.mock_inject_correlation_ids.assert_called() self.mock_patch_all.assert_called() def test_datadog_lambda_wrapper_flush_to_log(self): os.environ["DD_FLUSH_TO_LOG"] = "True" @datadog_lambda_wrapper def lambda_handler(event, context): lambda_metric("test.metric", 100) lambda_event = {} lambda_handler(lambda_event, get_mock_context()) self.mock_metric_lambda_stats.distribution.assert_not_called() self.mock_wrapper_lambda_stats.flush.assert_not_called() del os.environ["DD_FLUSH_TO_LOG"] def test_datadog_lambda_wrapper_inject_correlation_ids(self): os.environ["DD_LOGS_INJECTION"] = "True" @datadog_lambda_wrapper def lambda_handler(event, context): lambda_metric("test.metric", 100) lambda_event = {} lambda_handler(lambda_event, get_mock_context()) self.mock_set_correlation_ids.assert_called() self.mock_inject_correlation_ids.assert_called() del os.environ["DD_LOGS_INJECTION"] def test_invocations_metric(self): @datadog_lambda_wrapper def lambda_handler(event, context): lambda_metric("test.metric", 100) lambda_event = {} lambda_handler(lambda_event, get_mock_context()) self.mock_write_metric_point_to_stdout.assert_has_calls( [ call( "aws.lambda.enhanced.invocations", 1, tags=[ "region:us-west-1", "account_id:123457598159", "functionname:python-layer-test", "cold_start:true", "memorysize:256", "runtime:python2.7", "dd_lambda_layer:datadog-python27_0.1.0", ], ) ] ) def test_errors_metric(self): @datadog_lambda_wrapper def lambda_handler(event, context): raise RuntimeError() lambda_event = {} with self.assertRaises(RuntimeError): lambda_handler(lambda_event, get_mock_context()) self.mock_write_metric_point_to_stdout.assert_has_calls( [ call( "aws.lambda.enhanced.invocations", 1, tags=[ "region:us-west-1", "account_id:123457598159", "functionname:python-layer-test", "cold_start:true", "memorysize:256", "runtime:python2.7", "dd_lambda_layer:datadog-python27_0.1.0", ], ), call( "aws.lambda.enhanced.errors", 1, tags=[ "region:us-west-1", "account_id:123457598159", "functionname:python-layer-test", "cold_start:true", "memorysize:256", "runtime:python2.7", "dd_lambda_layer:datadog-python27_0.1.0", ], ), ] ) def test_enhanced_metrics_cold_start_tag(self): @datadog_lambda_wrapper def lambda_handler(event, context): lambda_metric("test.metric", 100) lambda_event = {} lambda_handler(lambda_event, get_mock_context()) self.mock_is_cold_start.return_value = False lambda_handler( lambda_event, get_mock_context(aws_request_id="second-request-id") ) self.mock_write_metric_point_to_stdout.assert_has_calls( [ call( "aws.lambda.enhanced.invocations", 1, tags=[ "region:us-west-1", "account_id:123457598159", "functionname:python-layer-test", "cold_start:true", "memorysize:256", "runtime:python2.7", "dd_lambda_layer:datadog-python27_0.1.0", ], ), call( "aws.lambda.enhanced.invocations", 1, tags=[ "region:us-west-1", "account_id:123457598159", "functionname:python-layer-test", "cold_start:false", "memorysize:256", "runtime:python2.7", "dd_lambda_layer:datadog-python27_0.1.0", ], ), ] ) def test_no_enhanced_metrics_without_env_var(self): os.environ["DD_ENHANCED_METRICS"] = "false" @datadog_lambda_wrapper def lambda_handler(event, context): raise RuntimeError() lambda_event = {} with self.assertRaises(RuntimeError): lambda_handler(lambda_event, get_mock_context()) self.mock_write_metric_point_to_stdout.assert_not_called() del os.environ["DD_ENHANCED_METRICS"] def test_only_one_wrapper_in_use(self): patcher = patch("datadog_lambda.wrapper.submit_invocations_metric") self.mock_submit_invocations_metric = patcher.start() self.addCleanup(patcher.stop) @datadog_lambda_wrapper def lambda_handler(event, context): lambda_metric("test.metric", 100) # Turn off _force_wrap to emulate the nested wrapper scenario, # the second @datadog_lambda_wrapper should actually be no-op. datadog_lambda_wrapper._force_wrap = False lambda_handler_double_wrapped = datadog_lambda_wrapper(lambda_handler) lambda_event = {} lambda_handler_double_wrapped(lambda_event, get_mock_context()) self.mock_patch_all.assert_called_once() self.mock_wrapper_lambda_stats.flush.assert_called_once() self.mock_submit_invocations_metric.assert_called_once()