diff --git a/datadog_lambda/cold_start.py b/datadog_lambda/cold_start.py index 9dcbec23..d4d4b8c2 100644 --- a/datadog_lambda/cold_start.py +++ b/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): diff --git a/datadog_lambda/handler.py b/datadog_lambda/handler.py index 09cc5e7d..777dc492 100644 --- a/datadog_lambda/handler.py +++ b/datadog_lambda/handler.py @@ -22,7 +22,7 @@ class HandlerError(Exception): ) 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 diff --git a/datadog_lambda/tag_object.py b/datadog_lambda/tag_object.py index ec1c5a66..5571bf53 100644 --- a/datadog_lambda/tag_object.py +++ b/datadog_lambda/tag_object.py @@ -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: diff --git a/datadog_lambda/tags.py b/datadog_lambda/tags.py index cdaeb4ed..3e12e2ff 100644 --- a/datadog_lambda/tags.py +++ b/datadog_lambda/tags.py @@ -1,7 +1,5 @@ import sys -from platform import python_version_tuple - from datadog_lambda import __version__ from datadog_lambda.cold_start import get_cold_start_tag @@ -10,8 +8,8 @@ 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__) + major, minor = sys.version_info[0], sys.version_info[1] + return f"dd_lambda_layer:datadog-python{major}{minor}_{__version__}" def tag_dd_lambda_layer(tags): @@ -44,9 +42,9 @@ def parse_lambda_tags_from_arn(lambda_context): # 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 @@ -56,12 +54,12 @@ def parse_lambda_tags_from_arn(lambda_context): 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) @@ -70,23 +68,20 @@ def parse_lambda_tags_from_arn(lambda_context): 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 - ) + major, minor = sys.version_info[0], sys.version_info[1] + return f"runtime:python{major}.{minor}" def get_library_version_tag(): """Get datadog lambda library tag""" - return "datadog_lambda:v{}".format(__version__) + return f"datadog_lambda:v{__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), + f"memorysize:{lambda_context.memory_limit_in_mb}", get_runtime_tag(), get_library_version_tag(), ] diff --git a/datadog_lambda/tracing.py b/datadog_lambda/tracing.py index ae2a0112..2769429f 100644 --- a/datadog_lambda/tracing.py +++ b/datadog_lambda/tracing.py @@ -734,7 +734,7 @@ def create_inferred_span_from_lambda_function_url_event(event, context): service_name = determine_service_name(service_mapping, api_id, "lambda_url", domain) method = request_context.get("http", {}).get("method") path = request_context.get("http", {}).get("path") - resource = "{0} {1}".format(method, path) + resource = f"{method} {path}" tags = { "operation_name": "aws.lambda.url", "http.url": domain + path, @@ -894,7 +894,7 @@ def create_inferred_span_from_api_gateway_event( method = event.get("httpMethod") path = event.get("path") resource_path = _get_resource_path(event, request_context) - resource = "{0} {1}".format(method, resource_path) + resource = f"{method} {resource_path}" tags = { "operation_name": "aws.apigateway.rest", "http.url": domain + path, @@ -959,7 +959,7 @@ def create_inferred_span_from_http_api_event( method = request_context.get("http", {}).get("method") path = event.get("rawPath") resource_path = _get_resource_path(event, request_context) - resource = "{0} {1}".format(method, resource_path) + resource = f"{method} {resource_path}" tags = { "operation_name": "aws.httpapi", "endpoint": path, diff --git a/datadog_lambda/trigger.py b/datadog_lambda/trigger.py index bbb44b30..0bb26d59 100644 --- a/datadog_lambda/trigger.py +++ b/datadog_lambda/trigger.py @@ -204,9 +204,7 @@ def parse_event_source_arn(source: _EventSource, event: dict, context: Any) -> s distribution_id = ( event_record.get("cf", {}).get("config", {}).get("distributionId") ) - return "arn:{}:cloudfront::{}:distribution/{}".format( - aws_arn, account_id, distribution_id - ) + return f"arn:{aws_arn}:cloudfront::{account_id}:distribution/{distribution_id}" # e.g. arn:aws:lambda:::url:: if source.equals(EventTypes.LAMBDA_FUNCTION_URL): @@ -223,9 +221,9 @@ def parse_event_source_arn(source: _EventSource, event: dict, context: Any) -> s # e.g. arn:aws:apigateway:us-east-1::/restapis/xyz123/stages/default if source.event_type == EventTypes.API_GATEWAY: request_context = event.get("requestContext") - return "arn:{}:apigateway:{}::/restapis/{}/stages/{}".format( - aws_arn, region, request_context.get("apiId"), request_context.get("stage") - ) + api_id = request_context.get("apiId") + stage = request_context.get("stage") + return f"arn:{aws_arn}:apigateway:{region}::/restapis/{api_id}/stages/{stage}" # e.g. arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/lambda-xyz/123 if source.event_type == EventTypes.ALB: @@ -240,9 +238,7 @@ def parse_event_source_arn(source: _EventSource, event: dict, context: Any) -> s data = b"".join(BufferedReader(decompress_stream)) logs = json.loads(data) log_group = logs.get("logGroup", "cloudwatch") - return "arn:{}:logs:{}:{}:log-group:{}".format( - aws_arn, region, account_id, log_group - ) + return f"arn:{aws_arn}:logs:{region}:{account_id}:log-group:{log_group}" # e.g. arn:aws:events:us-east-1:123456789012:rule/my-schedule if source.event_type == EventTypes.CLOUDWATCH_EVENTS and event.get("resources"): diff --git a/datadog_lambda/wrapper.py b/datadog_lambda/wrapper.py index 057f048c..3f6e044b 100644 --- a/datadog_lambda/wrapper.py +++ b/datadog_lambda/wrapper.py @@ -381,9 +381,8 @@ def _after(self, event, context): def format_err_with_traceback(e): - return "Error {}. Traceback: {}".format( - e, traceback.format_exc().replace("\n", "\r") - ) + tb = traceback.format_exc().replace("\n", "\r") + return f"Error {e}. Traceback: {tb}" datadog_lambda_wrapper = _LambdaDecorator diff --git a/datadog_lambda/xray.py b/datadog_lambda/xray.py index 88d108f5..db63a06f 100644 --- a/datadog_lambda/xray.py +++ b/datadog_lambda/xray.py @@ -41,7 +41,7 @@ def send(host_port_tuple, payload): def build_segment_payload(payload): if payload is None: return None - return '{"format": "json", "version": 1}' + "\n" + payload + return '{"format": "json", "version": 1}\n' + payload def parse_xray_header(raw_trace_id): diff --git a/tests/test_tags.py b/tests/test_tags.py index 66c0c39f..e50251c9 100644 --- a/tests/test_tags.py +++ b/tests/test_tags.py @@ -18,7 +18,7 @@ def get_mock_context( class TestMetricTags(unittest.TestCase): def setUp(self): - patcher = patch("datadog_lambda.tags.python_version_tuple") + patcher = patch("sys.version_info", (3, 12, 0)) self.mock_python_version_tuple = patcher.start() self.addCleanup(patcher.stop) @@ -65,5 +65,4 @@ def test_parse_lambda_tags_from_arn_alias(self): ) def test_get_runtime_tag(self): - self.mock_python_version_tuple.return_value = ("3", "12", "0") self.assertEqual(get_runtime_tag(), "runtime:python3.12") diff --git a/tests/test_wrapper.py b/tests/test_wrapper.py index 141e245a..bb26b661 100644 --- a/tests/test_wrapper.py +++ b/tests/test_wrapper.py @@ -61,14 +61,13 @@ def setUp(self): 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 + patcher = patch("datadog_lambda.tags.get_cold_start_tag") + self.mock_get_cold_start_tag = patcher.start() + self.mock_get_cold_start_tag.return_value = "cold_start:true" self.addCleanup(patcher.stop) - patcher = patch("datadog_lambda.tags.python_version_tuple") + patcher = patch("sys.version_info", (3, 9, 10)) self.mock_python_version_tuple = patcher.start() - self.mock_python_version_tuple.return_value = ("3", "9", "10") self.addCleanup(patcher.stop) patcher = patch("datadog_lambda.metric.write_metric_point_to_stdout") @@ -354,7 +353,7 @@ def lambda_handler(event, context): lambda_handler(lambda_event, get_mock_context()) - self.mock_is_cold_start.return_value = False + self.mock_get_cold_start_tag.return_value = "cold_start:false" lambda_handler( lambda_event, get_mock_context(aws_request_id="second-request-id")