datadog_lambda 5.92.0__py3-none-any.whl → 5.93.0__py3-none-any.whl

datadog_lambda/__init__.py

@@ -1,5 +1,4 @@
 from datadog_lambda.cold_start import initialize_cold_start_tracing
-from datadog_lambda.logger import initialize_logging
 import os
 
 
@@ -13,11 +12,8 @@ initialize_cold_start_tracing()
 
 # The minor version corresponds to the Lambda layer version.
 # E.g.,, version 0.5.0 gets packaged into layer version 5.
-try:
-    import importlib.metadata as importlib_metadata
-except ModuleNotFoundError:
-    import importlib_metadata
+from datadog_lambda.version import __version__  # noqa: E402 F401
+from datadog_lambda.logger import initialize_logging  # noqa: E402
 
-__version__ = importlib_metadata.version(__name__)
 
 initialize_logging(__name__)

datadog_lambda/cold_start.py

@@ -50,12 +50,16 @@ def is_new_sandbox():
 
 def get_cold_start_tag():
     """Returns the cold start tag to be used in metrics"""
-    return "cold_start:{}".format(str(is_cold_start()).lower())
+    return "cold_start:true" if _cold_start else "cold_start:false"
 
 
 def get_proactive_init_tag():
     """Returns the proactive init tag to be used in metrics"""
-    return "proactive_initialization:{}".format(str(is_proactive_init()).lower())
+    return (
+        "proactive_initialization:true"
+        if _proactive_initialization
+        else "proactive_initialization:false"
+    )
 
 
 class ImportNode(object):

datadog_lambda/extension.py

@@ -1,5 +1,5 @@
 import logging
-from os import path
+import os
 
 AGENT_URL = "http://127.0.0.1:8124"
 FLUSH_PATH = "/lambda/flush"
@@ -9,9 +9,7 @@ logger = logging.getLogger(__name__)
 
 
 def is_extension_present():
-    if path.exists(EXTENSION_PATH):
-        return True
-    return False
+    return os.path.exists(EXTENSION_PATH)
 
 
 def flush_extension():

datadog_lambda/handler.py

@@ -22,7 +22,7 @@ if path is None:
     )
 parts = path.rsplit(".", 1)
 if len(parts) != 2:
-    raise HandlerError("Value %s for DD_LAMBDA_HANDLER has invalid format." % path)
+    raise HandlerError(f"Value {path} for DD_LAMBDA_HANDLER has invalid format.")
 
 
 (mod_name, handler_name) = parts

datadog_lambda/metric.py

@@ -4,12 +4,12 @@
 # Copyright 2019 Datadog, Inc.
 
 import os
-import json
 import time
 import logging
+import ujson as json
 
 from datadog_lambda.extension import should_use_extension
-from datadog_lambda.tags import get_enhanced_metrics_tags, tag_dd_lambda_layer
+from datadog_lambda.tags import get_enhanced_metrics_tags, dd_lambda_layer_tag
 from datadog_lambda.api import init_api
 
 logger = logging.getLogger(__name__)
@@ -32,6 +32,10 @@ else:
     flush_in_thread = os.environ.get("DD_FLUSH_IN_THREAD", "").lower() == "true"
     lambda_stats = ThreadStatsWriter(flush_in_thread)
 
+enhanced_metrics_enabled = (
+    os.environ.get("DD_ENHANCED_METRICS", "true").lower() == "true"
+)
+
 
 def lambda_metric(metric_name, value, timestamp=None, tags=None, force_async=False):
     """
@@ -50,7 +54,8 @@ def lambda_metric(metric_name, value, timestamp=None, tags=None, force_async=Fal
     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)
+    tags = [] if tags is None else list(tags)
+    tags.append(dd_lambda_layer_tag)
 
     if should_use_extension:
         logger.debug(
@@ -80,7 +85,8 @@ def write_metric_point_to_stdout(metric_name, value, timestamp=None, tags=[]):
                 "v": value,
                 "e": timestamp or int(time.time()),
                 "t": tags,
-            }
+            },
+            escape_forward_slashes=False,
         )
     )
 
@@ -89,16 +95,6 @@ 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
 
@@ -106,7 +102,7 @@ def submit_enhanced_metric(metric_name, lambda_context):
         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():
+    if not enhanced_metrics_enabled:
         logger.debug(
             "Not submitting enhanced metric %s because enhanced metrics are disabled",
             metric_name,

datadog_lambda/patch.py

@@ -3,11 +3,11 @@
 # 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
+import ujson as json
 
 from wrapt import wrap_function_wrapper as wrap
 from wrapt.importer import when_imported
@@ -144,14 +144,14 @@ def _print_request_string(request):
         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)
+    sorted_data = json.dumps(data_dict, escape_forward_slashes=False)
 
     # 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)
+    sorted_header_str = json.dumps(sorted_headers, escape_forward_slashes=False)
     print(
         "HTTP {} {} Headers: {} Data: {}".format(
             method, url, sorted_header_str, sorted_data

datadog_lambda/tag_object.py

@@ -4,8 +4,8 @@
 # Copyright 2021 Datadog, Inc.
 
 from decimal import Decimal
-import json
 import logging
+import ujson as json
 
 redactable_keys = ["authorization", "x-authorization", "password", "token"]
 max_depth = 10
@@ -30,17 +30,17 @@ def tag_object(span, key, obj, depth=0):
         return span.set_tag(key, str(obj))
     if isinstance(obj, list):
         for k, v in enumerate(obj):
-            formatted_key = "{}.{}".format(key, k)
+            formatted_key = f"{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)
+            formatted_key = f"{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)
+            formatted_key = f"{key}.{k}"
             tag_object(span, formatted_key, v, depth)
         return
     try:

datadog_lambda/tags.py

@@ -1,28 +1,13 @@
 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]
+_major, _minor = sys.version_info[0], sys.version_info[1]
+dd_lambda_layer_tag = f"dd_lambda_layer:datadog-python{_major}{_minor}_{__version__}"
+runtime_tag = f"runtime:python{_major}.{_minor}"
+library_version_tag = f"datadog_lambda:v{__version__}"
 
 
 def parse_lambda_tags_from_arn(lambda_context):
@@ -32,64 +17,50 @@ def parse_lambda_tags_from_arn(lambda_context):
             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
+    has_alias = False
     # Cap the number of times to spli
     split_arn = lambda_context.invoked_function_arn.split(":")
 
     if len(split_arn) > 7:
-        hasAlias = True
+        has_alias = 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),
+        f"region:{region}",
+        f"account_id:{account_id}",
+        f"functionname:{function_name}",
     ]
 
     # Check if we have a version or alias
-    if hasAlias:
+    if has_alias:
         # 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))
+            tags.append(f"executedversion:{lambda_context.function_version}")
         # create resource tag with function name and alias/version
-        resource = "resource:{}:{}".format(function_name, alias)
+        resource = f"resource:{function_name}:{alias}"
     else:
         # Resource is only the function name otherwise
-        resource = "resource:{}".format(function_name)
+        resource = f"resource:{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(),
-    ]
+    tags = parse_lambda_tags_from_arn(lambda_context)
+    tags.append(get_cold_start_tag())
+    tags.append(f"memorysize:{lambda_context.memory_limit_in_mb}")
+    tags.append(runtime_tag)
+    tags.append(library_version_tag)
+    return tags
 
 
 def check_if_number(alias):