datadog_lambda 5.91.0__py3-none-any.whl

datadog_lambda/metric.py

@@ -0,0 +1,136 @@
+# 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 logging
+
+from datadog_lambda.extension import should_use_extension
+from datadog_lambda.tags import get_enhanced_metrics_tags, tag_dd_lambda_layer
+from datadog_lambda.api import init_api
+
+logger = logging.getLogger(__name__)
+
+lambda_stats = None
+
+init_api()
+
+if should_use_extension:
+    from datadog_lambda.statsd_writer import StatsDWriter
+
+    lambda_stats = StatsDWriter()
+else:
+    # Periodical flushing in a background thread is NOT guaranteed to succeed
+    # and leads to data loss. When disabled, metrics are only flushed at the
+    # end of invocation. To make metrics submitted from a long-running Lambda
+    # function available sooner, consider using the Datadog Lambda extension.
+    from datadog_lambda.thread_stats_writer import ThreadStatsWriter
+
+    flush_in_thread = os.environ.get("DD_FLUSH_IN_THREAD", "").lower() == "true"
+    lambda_stats = ThreadStatsWriter(flush_in_thread)
+
+
+def lambda_metric(metric_name, value, timestamp=None, tags=None, force_async=False):
+    """
+    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.
+
+    Note that if the extension is present, it will override the DD_FLUSH_TO_LOG value
+    and always use the layer to send metrics to the extension
+    """
+    flush_to_logs = os.environ.get("DD_FLUSH_TO_LOG", "").lower() == "true"
+    tags = tag_dd_lambda_layer(tags)
+
+    if should_use_extension:
+        logger.debug(
+            "Sending metric %s value %s to Datadog via extension", metric_name, value
+        )
+        lambda_stats.distribution(metric_name, value, tags=tags, timestamp=timestamp)
+    else:
+        if flush_to_logs or force_async:
+            write_metric_point_to_stdout(
+                metric_name, value, timestamp=timestamp, tags=tags
+            )
+        else:
+            lambda_stats.distribution(
+                metric_name, value, tags=tags, timestamp=timestamp
+            )
+
+
+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 flush_stats():
+    lambda_stats.flush()
+
+
+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
+    tags = get_enhanced_metrics_tags(lambda_context)
+    metric_name = "aws.lambda.enhanced." + metric_name
+    # Enhanced metrics always use an async submission method, (eg logs or extension).
+    lambda_metric(metric_name, 1, timestamp=None, tags=tags, force_async=True)
+
+
+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)

datadog_lambda/module_name.py

@@ -0,0 +1,3 @@
+def modify_module_name(module_name):
+    """Returns a valid modified module to get imported"""
+    return ".".join(module_name.split("/"))

datadog_lambda/patch.py

@@ -0,0 +1,159 @@
+# 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
+import zlib
+
+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,
+)
+from collections.abc import MutableMapping
+
+logger = logging.getLogger(__name__)
+
+_http_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_http()
+        _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_http():
+    """
+    Patch `http.client` (Python 3) module.
+    """
+    global _http_patched
+    http_module = "http.client"
+    if not _http_patched:
+        _http_patched = True
+        wrap(http_module, "HTTPConnection.request", _wrap_http_request)
+
+    logger.debug("Patched %s", http_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_http_request(func, instance, args, kwargs):
+    """
+    Wrap `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 "{}"
+    # If payload is compressed, decompress it so we can parse it
+    if request.headers.get("Content-Encoding") == "deflate":
+        data = zlib.decompress(data)
+    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/stats_writer.py

@@ -0,0 +1,9 @@
+class StatsWriter:
+    def distribution(self, metric_name, value, tags=[], timestamp=None):
+        raise NotImplementedError()
+
+    def flush(self):
+        raise NotImplementedError()
+
+    def stop(self):
+        raise NotImplementedError()

datadog_lambda/statsd_writer.py

@@ -0,0 +1,17 @@
+from datadog_lambda.stats_writer import StatsWriter
+from datadog_lambda.dogstatsd import statsd
+
+
+class StatsDWriter(StatsWriter):
+    """
+    Writes distribution metrics using StatsD protocol
+    """
+
+    def distribution(self, metric_name, value, tags=[], timestamp=None):
+        statsd.distribution(metric_name, value, tags=tags)
+
+    def flush(self):
+        pass
+
+    def stop(self):
+        pass

datadog_lambda/tag_object.py

@@ -0,0 +1,68 @@
+# 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 2021 Datadog, Inc.
+
+from decimal import Decimal
+import json
+import logging
+
+redactable_keys = ["authorization", "x-authorization", "password", "token"]
+max_depth = 10
+logger = logging.getLogger(__name__)
+
+
+def tag_object(span, key, obj, depth=0):
+    if obj is None:
+        return span.set_tag(key, obj)
+    if depth >= max_depth:
+        return span.set_tag(key, _redact_val(key, str(obj)[0:5000]))
+    depth += 1
+    if _should_try_string(obj):
+        parsed = None
+        try:
+            parsed = json.loads(obj)
+            return tag_object(span, key, parsed, depth)
+        except ValueError:
+            redacted = _redact_val(key, obj[0:5000])
+            return span.set_tag(key, redacted)
+    if isinstance(obj, int) or isinstance(obj, float) or isinstance(obj, Decimal):
+        return span.set_tag(key, str(obj))
+    if isinstance(obj, list):
+        for k, v in enumerate(obj):
+            formatted_key = "{}.{}".format(key, k)
+            tag_object(span, formatted_key, v, depth)
+        return
+    if hasattr(obj, "items"):
+        for k, v in obj.items():
+            formatted_key = "{}.{}".format(key, k)
+            tag_object(span, formatted_key, v, depth)
+        return
+    if hasattr(obj, "to_dict"):
+        for k, v in obj.to_dict().items():
+            formatted_key = "{}.{}".format(key, k)
+            tag_object(span, formatted_key, v, depth)
+        return
+    try:
+        value_as_str = str(obj)
+    except Exception:
+        value_as_str = "UNKNOWN"
+    return span.set_tag(key, value_as_str)
+
+
+def _should_try_string(obj):
+    try:
+        if isinstance(obj, str) or isinstance(obj, unicode):
+            return True
+    except NameError:
+        if isinstance(obj, bytes):
+            return True
+
+    return False
+
+
+def _redact_val(k, v):
+    split_key = k.split(".").pop() or k
+    if split_key in redactable_keys:
+        return "redacted"
+    return v

datadog_lambda/tags.py

@@ -0,0 +1,104 @@
+import 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-python39_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(lambda_context):
+    """Generate the list of lambda tags based on the data in the arn
+    Args:
+        lambda_context: Aws lambda context object
+            ex: lambda_context.arn = arn:aws:lambda:us-east-1:123597598159:function:my-lambda:1
+    """
+    # Set up flag for extra testing to distinguish between a version or alias
+    hasAlias = False
+    # Cap the number of times to spli
+    split_arn = lambda_context.invoked_function_arn.split(":")
+
+    if len(split_arn) > 7:
+        hasAlias = True
+        _, _, _, region, account_id, _, function_name, alias = split_arn
+    else:
+        _, _, _, region, account_id, _, function_name = split_arn
+
+    # Add the standard tags to a list
+    tags = [
+        "region:{}".format(region),
+        "account_id:{}".format(account_id),
+        "functionname:{}".format(function_name),
+    ]
+
+    # Check if we have a version or alias
+    if hasAlias:
+        # If $Latest, drop the $ for datadog tag convention. A lambda alias can't start with $
+        if alias.startswith("$"):
+            alias = alias[1:]
+        # Versions are numeric. Aliases need the executed version tag
+        elif not check_if_number(alias):
+            tags.append("executedversion:{}".format(lambda_context.function_version))
+        # create resource tag with function name and alias/version
+        resource = "resource:{}:{}".format(function_name, alias)
+    else:
+        # Resource is only the function name otherwise
+        resource = "resource:{}".format(function_name)
+
+    tags.append(resource)
+
+    return tags
+
+
+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_library_version_tag():
+    """Get datadog lambda library tag"""
+    return "datadog_lambda:v{}".format(__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) + [
+        get_cold_start_tag(),
+        "memorysize:{}".format(lambda_context.memory_limit_in_mb),
+        get_runtime_tag(),
+        get_library_version_tag(),
+    ]
+
+
+def check_if_number(alias):
+    """
+    Check if the alias is a version or number.
+    Python 2 has no easy way to test this like Python 3
+    """
+    try:
+        float(alias)
+        return True
+    except ValueError:
+        return False

datadog_lambda/thread_stats_writer.py

@@ -0,0 +1,65 @@
+import logging
+
+# Make sure that this package would always be lazy-loaded/outside from the critical path
+# since underlying packages are quite heavy to load and useless when the extension is present
+from datadog.threadstats import ThreadStats
+from datadog_lambda.stats_writer import StatsWriter
+
+logger = logging.getLogger(__name__)
+
+
+class ThreadStatsWriter(StatsWriter):
+    """
+    Writes distribution metrics using the ThreadStats class
+    """
+
+    def __init__(self, flush_in_thread):
+        self.thread_stats = ThreadStats(compress_payload=True)
+        self.thread_stats.start(flush_in_thread=flush_in_thread)
+
+    def distribution(self, metric_name, value, tags=[], timestamp=None):
+        self.thread_stats.distribution(
+            metric_name, value, tags=tags, timestamp=timestamp
+        )
+
+    def flush(self):
+        """ "Flush distributions from ThreadStats to Datadog.
+        Modified based on `datadog.threadstats.base.ThreadStats.flush()`,
+        to gain better control over exception handling.
+        """
+        _, dists = self.thread_stats._get_aggregate_metrics_and_dists(float("inf"))
+        count_dists = len(dists)
+        if not count_dists:
+            logger.debug("No distributions to flush. Continuing.")
+
+        self.thread_stats.flush_count += 1
+        logger.debug(
+            "Flush #%s sending %s distributions",
+            self.thread_stats.flush_count,
+            count_dists,
+        )
+        try:
+            self.thread_stats.reporter.flush_distributions(dists)
+        except Exception as e:
+            # The nature of the root issue https://bugs.python.org/issue41345 is complex,
+            # but comprehensive tests suggest that it is safe to retry on this specific error.
+            if type(e).__name__ == "ClientError" and "RemoteDisconnected" in str(e):
+                logger.debug(
+                    "Retry flush #%s due to RemoteDisconnected",
+                    self.thread_stats.flush_count,
+                )
+                try:
+                    self.thread_stats.reporter.flush_distributions(dists)
+                except Exception:
+                    logger.debug(
+                        "Flush #%s failed after retry",
+                        self.thread_stats.flush_count,
+                        exc_info=True,
+                    )
+            else:
+                logger.debug(
+                    "Flush #%s failed", self.thread_stats.flush_count, exc_info=True
+                )
+
+    def stop(self):
+        self.thread_stats.stop()