ddtrace 3.11.0rc1__cp312-cp312-musllinux_1_2_aarch64.whl → 3.11.0rc3__cp312-cp312-musllinux_1_2_aarch64.whl

ddtrace/contrib/internal/langchain/utils.py

@@ -106,32 +106,6 @@ def shared_stream(
         raise
 
 
-def tag_general_message_input(span, inputs, integration, langchain_core):
-    if langchain_core and isinstance(inputs, langchain_core.prompt_values.PromptValue):
-        inputs = inputs.to_messages()
-    elif not isinstance(inputs, list):
-        inputs = [inputs]
-    for input_idx, inp in enumerate(inputs):
-        if isinstance(inp, dict):
-            span.set_tag_str(
-                "langchain.request.messages.%d.content" % (input_idx),
-                integration.trunc(str(inp.get("content", ""))),
-            )
-            role = inp.get("role")
-            if role is not None:
-                span.set_tag_str(
-                    "langchain.request.messages.%d.message_type" % (input_idx),
-                    str(inp.get("role", "")),
-                )
-        elif langchain_core and isinstance(inp, langchain_core.messages.BaseMessage):
-            content = inp.content
-            role = inp.__class__.__name__
-            span.set_tag_str("langchain.request.messages.%d.content" % (input_idx), integration.trunc(str(content)))
-            span.set_tag_str("langchain.request.messages.%d.message_type" % (input_idx), str(role))
-        else:
-            span.set_tag_str("langchain.request.messages.%d.content" % (input_idx), integration.trunc(str(inp)))
-
-
 def _get_chunk_callback(interface_type, args, kwargs):
     results = core.dispatch_with_results("langchain.stream.chunk.callback", (interface_type, args, kwargs))
     callbacks = []

ddtrace/contrib/internal/logbook/patch.py

@@ -5,7 +5,6 @@ from wrapt import wrap_function_wrapper as _w
 
 import ddtrace
 from ddtrace import config
-from ddtrace._logger import LogInjectionState
 from ddtrace.contrib.internal.trace_utils import unwrap as _u
 from ddtrace.internal.utils import get_argument_value
 
@@ -27,7 +26,7 @@ def _supported_versions() -> Dict[str, str]:
 
 def _w_process_record(func, instance, args, kwargs):
     # patch logger to include datadog info before logging
-    if config._logs_injection != LogInjectionState.DISABLED:
+    if config._logs_injection:
         record = get_argument_value(args, kwargs, 0, "record")
         record.extra.update(ddtrace.tracer.get_log_correlation_context())
     return func(*args, **kwargs)

ddtrace/contrib/internal/logging/patch.py

@@ -5,7 +5,6 @@ from wrapt import wrap_function_wrapper as _w
 
 import ddtrace
 from ddtrace import config
-from ddtrace._logger import LogInjectionState
 from ddtrace._logger import set_log_formatting
 from ddtrace.contrib.internal.trace_utils import unwrap as _u
 from ddtrace.internal.constants import LOG_ATTR_ENV
@@ -54,15 +53,13 @@ class DDLogRecord:
 def _w_makeRecord(func, instance, args, kwargs):
     # Get the LogRecord instance for this log
     record = func(*args, **kwargs)
-    if config._logs_injection == LogInjectionState.DISABLED:
-        # log injection is opt-in for non-structured logging
-        return record
-    record.__dict__.update(ddtrace.tracer.get_log_correlation_context())
+    if config._logs_injection:
+        record.__dict__.update(ddtrace.tracer.get_log_correlation_context())
     return record
 
 
 def _w_StrFormatStyle_format(func, instance, args, kwargs):
-    if config._logs_injection != LogInjectionState.ENABLED:
+    if not config._logs_injection:
         return func(*args, **kwargs)
     # The format string "dd.service={dd.service}" expects
     # the record to have a "dd" property which is an object that
@@ -103,7 +100,7 @@ def patch():
     _w(logging.Logger, "makeRecord", _w_makeRecord)
     _w(logging.StrFormatStyle, "_format", _w_StrFormatStyle_format)
 
-    if config._logs_injection == LogInjectionState.ENABLED:
+    if config._logs_injection:
         # Only set the formatter is DD_LOGS_INJECTION is set to True. We do not want to modify
         # unstructured logs if a user has not enabled logs injection.
         # Also, the Datadog log format must be set after the logging module has been patched,

ddtrace/contrib/internal/loguru/patch.py

@@ -5,7 +5,6 @@ from wrapt import wrap_function_wrapper as _w
 
 import ddtrace
 from ddtrace import config
-from ddtrace._logger import LogInjectionState
 from ddtrace.contrib.internal.trace_utils import unwrap as _u
 
 
@@ -25,12 +24,11 @@ def _supported_versions() -> Dict[str, str]:
 
 
 def _tracer_injection(event_dict):
-    if config._logs_injection == LogInjectionState.DISABLED:
+    if not config._logs_injection:
         # log injection is opt-out for structured logging
         return event_dict
     event_dd_attributes = ddtrace.tracer.get_log_correlation_context()
     event_dict.update(event_dd_attributes)
-
     return event_dd_attributes
 
 

ddtrace/contrib/internal/openai_agents/patch.py

@@ -5,6 +5,10 @@ from agents.tracing import add_trace_processor
 
 from ddtrace import config
 from ddtrace.contrib.internal.openai_agents.processor import LLMObsTraceProcessor
+from ddtrace.contrib.trace_utils import unwrap
+from ddtrace.contrib.trace_utils import with_traced_module_async
+from ddtrace.contrib.trace_utils import wrap
+from ddtrace.internal.utils.version import parse_version
 from ddtrace.llmobs._integrations.openai_agents import OpenAIAgentsIntegration
 from ddtrace.trace import Pin
 
@@ -22,6 +26,29 @@ def _supported_versions() -> Dict[str, str]:
     return {"agents": ">=0.0.2"}
 
 
+OPENAI_AGENTS_VERSION = parse_version(get_version())
+
+
+@with_traced_module_async
+async def patched_run_single_turn(agents, pin, func, instance, args, kwargs):
+    return await _patched_run_single_turn(agents, pin, func, instance, args, kwargs, agent_index=0)
+
+
+@with_traced_module_async
+async def patched_run_single_turn_streamed(agents, pin, func, instance, args, kwargs):
+    return await _patched_run_single_turn(agents, pin, func, instance, args, kwargs, agent_index=1)
+
+
+async def _patched_run_single_turn(agents, pin, func, instance, args, kwargs, agent_index=0):
+    current_span = pin.tracer.current_span()
+    result = await func(*args, **kwargs)
+
+    integration = agents._datadog_integration
+    integration.tag_agent_manifest(current_span, args, kwargs, agent_index)
+
+    return result
+
+
 def patch():
     """
     Patch the instrumented methods
@@ -33,7 +60,16 @@ def patch():
 
     Pin().onto(agents)
 
-    add_trace_processor(LLMObsTraceProcessor(OpenAIAgentsIntegration(integration_config=config.openai_agents)))
+    integration = OpenAIAgentsIntegration(integration_config=config.openai_agents)
+    add_trace_processor(LLMObsTraceProcessor(integration))
+    agents._datadog_integration = integration
+
+    if OPENAI_AGENTS_VERSION >= (0, 0, 19):
+        wrap(agents.run.AgentRunner, "_run_single_turn", patched_run_single_turn(agents))
+        wrap(agents.run.AgentRunner, "_run_single_turn_streamed", patched_run_single_turn_streamed(agents))
+    else:
+        wrap(agents.run.Runner, "_run_single_turn", patched_run_single_turn(agents))
+        wrap(agents.run.Runner, "_run_single_turn_streamed", patched_run_single_turn_streamed(agents))
 
 
 def unpatch():
@@ -44,3 +80,10 @@ def unpatch():
         return
 
     agents._datadog_patch = False
+
+    if OPENAI_AGENTS_VERSION >= (0, 0, 19):
+        unwrap(agents.run.AgentRunner, "_run_single_turn")
+        unwrap(agents.run.AgentRunner, "_run_single_turn_streamed")
+    else:
+        unwrap(agents.run.Runner, "_run_single_turn")
+        unwrap(agents.run.Runner, "_run_single_turn_streamed")

ddtrace/contrib/internal/protobuf/__init__.py

@@ -0,0 +1,17 @@
+"""
+The Protobuf integration will trace all Protobuf read / write calls made with the ``google.protobuf``
+library. This integration is enabled by default.
+
+Enabling
+~~~~~~~~
+
+The protobuf integration is enabled by default. Use
+:func:`patch()<ddtrace.patch>` to enable the integration::
+
+    from ddtrace import patch
+    patch(protobuf=True)
+
+Configuration
+~~~~~~~~~~~~~
+
+"""

ddtrace/contrib/internal/pytest/__init__.py

@@ -0,0 +1,62 @@
+"""
+The pytest integration traces test executions.
+
+Enabling
+~~~~~~~~
+
+Enable traced execution of tests using ``pytest`` runner by
+running ``pytest --ddtrace`` or by modifying any configuration
+file read by pytest (``pytest.ini``, ``setup.cfg``, ...)::
+
+    [pytest]
+    ddtrace = 1
+
+
+If you need to disable it, the option ``--no-ddtrace`` will take
+precedence over ``--ddtrace`` and (``pytest.ini``, ``setup.cfg``, ...)
+
+You can enable all integrations by using the ``--ddtrace-patch-all`` option
+alongside ``--ddtrace`` or by adding this to your configuration::
+
+    [pytest]
+    ddtrace = 1
+    ddtrace-patch-all = 1
+
+
+.. note::
+   The ddtrace plugin for pytest has the side effect of importing the ddtrace
+   package and starting a global tracer.
+
+   If this is causing issues for your pytest runs where traced execution of
+   tests is not enabled, you can deactivate the plugin::
+
+     [pytest]
+     addopts = -p no:ddtrace
+
+   See the `pytest documentation
+   <https://docs.pytest.org/en/7.1.x/how-to/plugins.html#deactivating-unregistering-a-plugin-by-name>`_
+   for more details.
+
+
+Global Configuration
+~~~~~~~~~~~~~~~~~~~~
+
+.. py:data:: ddtrace.config.pytest["service"]
+
+   The service name reported by default for pytest traces.
+
+   This option can also be set with the integration specific ``DD_PYTEST_SERVICE`` environment
+   variable, or more generally with the `DD_SERVICE` environment variable.
+
+   Default: Name of the repository being tested, otherwise ``"pytest"`` if the repository name cannot be found.
+
+
+.. py:data:: ddtrace.config.pytest["operation_name"]
+
+   The operation name reported by default for pytest traces.
+
+   This option can also be set with the ``DD_PYTEST_OPERATION_NAME`` environment
+   variable.
+
+   Default: ``"pytest.test"``
+"""

ddtrace/contrib/internal/pytest/_plugin_v2.py

@@ -237,11 +237,12 @@ def _pytest_load_initial_conftests_pre_yield(early_config, parser, args):
     ModuleCodeCollector has a tangible impact on the time it takes to load modules, so it should only be installed if
     coverage collection is requested by the backend.
     """
+    take_over_logger_stream_handler()
+
     if not _is_enabled_early(early_config, args):
         return
 
     try:
-        take_over_logger_stream_handler()
         dd_config.test_visibility.itr_skipping_level = ITR_SKIPPING_LEVEL.SUITE
         enable_test_visibility(config=dd_config.pytest)
         if InternalTestSession.should_collect_coverage():
@@ -344,7 +345,7 @@ def pytest_sessionstart(session: pytest.Session) -> None:
             test_impact_analysis="1" if _pytest_version_supports_itr() else None,
             test_management_quarantine="1",
             test_management_disable="1",
-            test_management_attempt_to_fix="4" if _pytest_version_supports_attempt_to_fix() else None,
+            test_management_attempt_to_fix="5" if _pytest_version_supports_attempt_to_fix() else None,
         )
 
         InternalTestSession.discover(
@@ -824,8 +825,16 @@ def _pytest_sessionfinish(session: pytest.Session, exitstatus: int) -> None:
             run_coverage_report()
 
         lines_pct_value = _coverage_data.get(PCT_COVERED_KEY, None)
-        if not isinstance(lines_pct_value, float):
-            log.warning("Tried to add total covered percentage to session span but the format was unexpected")
+        if lines_pct_value is None:
+            log.debug("Unable to retrieve coverage data for the session span")
+        elif not isinstance(lines_pct_value, (float, int)):
+            t = type(lines_pct_value)
+            log.warning(
+                "Unexpected format for total covered percentage: type=%s.%s, value=%r",
+                t.__module__,
+                t.__name__,
+                lines_pct_value,
+            )
         else:
             InternalTestSession.set_covered_lines_pct(lines_pct_value)
 

ddtrace/contrib/internal/pytest_bdd/__init__.py

@@ -0,0 +1,23 @@
+"""
+The pytest-bdd integration traces executions of scenarios and steps.
+
+Enabling
+~~~~~~~~
+
+Please follow the instructions for enabling `pytest` integration.
+
+.. note::
+   The ddtrace.pytest_bdd plugin for pytest-bdd has the side effect of importing
+   the ddtrace package and starting a global tracer.
+
+   If this is causing issues for your pytest-bdd runs where traced execution of
+   tests is not enabled, you can deactivate the plugin::
+
+     [pytest]
+     addopts = -p no:ddtrace.pytest_bdd
+
+   See the `pytest documentation
+   <https://docs.pytest.org/en/7.1.x/how-to/plugins.html#deactivating-unregistering-a-plugin-by-name>`_
+   for more details.
+
+"""

ddtrace/contrib/internal/pytest_benchmark/__init__.py

@@ -0,0 +1,3 @@
+"""
+The pytest-benchmark integration traces executions of pytest benchmarks.
+"""

ddtrace/contrib/internal/structlog/patch.py

@@ -4,7 +4,6 @@ import structlog
 
 import ddtrace
 from ddtrace import config
-from ddtrace._logger import LogInjectionState
 from ddtrace.contrib.internal.trace_utils import unwrap as _u
 from ddtrace.contrib.internal.trace_utils import wrap as _w
 from ddtrace.internal.utils import get_argument_value
@@ -27,9 +26,8 @@ def _supported_versions() -> Dict[str, str]:
 
 
 def _tracer_injection(_, __, event_dict):
-    if config._logs_injection == LogInjectionState.DISABLED:
-        return event_dict
-    event_dict.update(ddtrace.tracer.get_log_correlation_context())
+    if config._logs_injection:
+        event_dict.update(ddtrace.tracer.get_log_correlation_context())
     return event_dict
 
 

ddtrace/contrib/internal/unittest/__init__.py

@@ -0,0 +1,36 @@
+"""
+The unittest integration traces test executions.
+
+
+Enabling
+~~~~~~~~
+
+The unittest integration is enabled automatically when using
+:ref:`ddtrace-run<ddtracerun>` or :ref:`import ddtrace.auto<ddtraceauto>`.
+
+Alternately, use :func:`patch()<ddtrace.patch>` to manually enable the integration::
+
+    from ddtrace import patch
+    patch(unittest=True)
+
+Global Configuration
+~~~~~~~~~~~~~~~~~~~~
+
+.. py:data:: ddtrace.config.unittest["operation_name"]
+
+   The operation name reported by default for unittest traces.
+
+   This option can also be set with the ``DD_UNITTEST_OPERATION_NAME`` environment
+   variable.
+
+   Default: ``"unittest.test"``
+
+.. py:data:: ddtrace.config.unittest["strict_naming"]
+
+   Requires all ``unittest`` tests to start with ``test`` as stated in the Python documentation
+
+   This option can also be set with the ``DD_CIVISIBILITY_UNITTEST_STRICT_NAMING`` environment
+   variable.
+
+   Default: ``True``
+"""

ddtrace/contrib/internal/vertexai/patch.py

@@ -14,7 +14,7 @@ from ddtrace.contrib.internal.trace_utils import wrap
 from ddtrace.contrib.internal.vertexai._utils import TracedAsyncVertexAIStreamResponse
 from ddtrace.contrib.internal.vertexai._utils import TracedVertexAIStreamResponse
 from ddtrace.llmobs._integrations import VertexAIIntegration
-from ddtrace.llmobs._integrations.utils import extract_model_name_google
+from ddtrace.llmobs._integrations.google_utils import extract_provider_and_model_name
 from ddtrace.trace import Pin
 
 
@@ -60,11 +60,12 @@ def _traced_generate(vertexai, pin, func, instance, args, kwargs, model_instance
     integration = vertexai._datadog_integration
     stream = kwargs.get("stream", False)
     generations = None
+    provider_name, model_name = extract_provider_and_model_name(instance=model_instance, model_name_attr="_model_name")
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),
-        provider="google",
-        model=extract_model_name_google(model_instance, "_model_name"),
+        provider=provider_name,
+        model=model_name,
         submit_to_llmobs=True,
     )
     # history must be copied since it is modified during the LLM interaction
@@ -92,11 +93,12 @@ async def _traced_agenerate(vertexai, pin, func, instance, args, kwargs, model_i
     integration = vertexai._datadog_integration
     stream = kwargs.get("stream", False)
     generations = None
+    provider_name, model_name = extract_provider_and_model_name(instance=model_instance, model_name_attr="_model_name")
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),
-        provider="google",
-        model=extract_model_name_google(model_instance, "_model_name"),
+        provider=provider_name,
+        model=model_name,
         submit_to_llmobs=True,
     )
     # history must be copied since it is modified during the LLM interaction

ddtrace/ext/ci.py

@@ -105,6 +105,16 @@ def tags(env=None, cwd=None):
             break
 
     git_info = git.extract_git_metadata(cwd=cwd)
+
+    # Whenever the HEAD commit SHA is present in the tags that come from the CI provider, we assume that
+    # the CI provider added a commit on top of the user's HEAD commit (e.g., GitHub Actions add a merge
+    # commit when triggered by a pull request). In that case, we extract the metadata for that commit specifically
+    # and add it to the tags.
+    head_commit_sha = tags.get(git.COMMIT_HEAD_SHA)
+    if head_commit_sha:
+        git_head_info = git.extract_git_head_metadata(head_commit_sha=head_commit_sha, cwd=cwd)
+        git_info.update(git_head_info)
+
     try:
         git_info[WORKSPACE_PATH] = git.extract_workspace_path(cwd=cwd)
     except git.GitNotFoundError:
@@ -349,6 +359,15 @@ def extract_github_actions(env):
         github_run_id,
     )
 
+    git_commit_head_sha = None
+    if "GITHUB_EVENT_PATH" in env:
+        try:
+            with open(env["GITHUB_EVENT_PATH"]) as f:
+                github_event_data = json.load(f)
+                git_commit_head_sha = github_event_data.get("pull_request", {}).get("head", {}).get("sha")
+        except Exception as e:
+            log.error("Failed to read or parse GITHUB_EVENT_PATH: %s", e)
+
     env_vars = {
         "GITHUB_SERVER_URL": github_server_url,
         "GITHUB_REPOSITORY": github_repository,
@@ -362,6 +381,7 @@ def extract_github_actions(env):
         git.BRANCH: env.get("GITHUB_HEAD_REF") or env.get("GITHUB_REF"),
         git.COMMIT_SHA: git_commit_sha,
         git.REPOSITORY_URL: "{0}/{1}.git".format(github_server_url, github_repository),
+        git.COMMIT_HEAD_SHA: git_commit_head_sha,
         JOB_URL: "{0}/{1}/commit/{2}/checks".format(github_server_url, github_repository, git_commit_sha),
         PIPELINE_ID: github_run_id,
         PIPELINE_NAME: env.get("GITHUB_WORKFLOW"),

ddtrace/ext/git.py

@@ -33,6 +33,30 @@ BRANCH = "git.branch"
 # Git Commit SHA
 COMMIT_SHA = "git.commit.sha"
 
+# Git Commit HEAD SHA
+COMMIT_HEAD_SHA = "git.commit.head.sha"
+
+# Git Commit HEAD message
+COMMIT_HEAD_MESSAGE = "git.commit.head.message"
+
+# Git Commit HEAD author date
+COMMIT_HEAD_AUTHOR_DATE = "git.commit.head.author.date"
+
+# Git Commit HEAD author email
+COMMIT_HEAD_AUTHOR_EMAIL = "git.commit.head.author.email"
+
+# Git Commit HEAD author name
+COMMIT_HEAD_AUTHOR_NAME = "git.commit.head.author.name"
+
+# Git Commit HEAD committer date
+COMMIT_HEAD_COMMITTER_DATE = "git.commit.head.committer.date"
+
+# Git Commit HEAD committer email
+COMMIT_HEAD_COMMITTER_EMAIL = "git.commit.head.committer.email"
+
+# Git Commit HEAD committer name
+COMMIT_HEAD_COMMITTER_NAME = "git.commit.head.committer.name"
+
 # Git Repository URL
 REPOSITORY_URL = "git.repository_url"
 
@@ -173,11 +197,12 @@ def _get_device_for_path(path):
     return os.stat(path).st_dev
 
 
-def _unshallow_repository_with_details(cwd=None, repo=None, refspec=None):
-    # type (Optional[str], Optional[str], Optional[str]) -> _GitSubprocessDetails
+def _unshallow_repository_with_details(
+    cwd: Optional[str] = None, repo: Optional[str] = None, refspec: Optional[str] = None, parent_only: bool = False
+) -> _GitSubprocessDetails:
     cmd = [
         "fetch",
-        '--shallow-since="1 month ago"',
+        "--deepen=1" if parent_only else '--shallow-since="1 month ago"',
         "--update-shallow",
         "--filter=blob:none",
         "--recurse-submodules=no",
@@ -190,18 +215,22 @@ def _unshallow_repository_with_details(cwd=None, repo=None, refspec=None):
     return _git_subprocess_cmd_with_details(*cmd, cwd=cwd)
 
 
-def _unshallow_repository(cwd=None, repo=None, refspec=None):
-    # type (Optional[str], Optional[str], Optional[str]) -> None
-    _unshallow_repository_with_details(cwd, repo, refspec)
+def _unshallow_repository(
+    cwd: Optional[str] = None,
+    repo: Optional[str] = None,
+    refspec: Optional[str] = None,
+    parent_only: bool = False,
+) -> None:
+    _unshallow_repository_with_details(cwd, repo, refspec, parent_only)
 
 
-def extract_user_info(cwd=None):
-    # type: (Optional[str]) -> Dict[str, Tuple[str, str, str]]
+def extract_user_info(cwd: Optional[str] = None, commit_sha: Optional[str] = None) -> Dict[str, Tuple[str, str, str]]:
     """Extract commit author info from the git repository in the current directory or one specified by ``cwd``."""
     # Note: `git show -s --format... --date...` is supported since git 2.1.4 onwards
-    stdout = _git_subprocess_cmd(
-        "show -s --format=%an|||%ae|||%ad|||%cn|||%ce|||%cd --date=format:%Y-%m-%dT%H:%M:%S%z", cwd=cwd
-    )
+    cmd = "show -s --format=%an|||%ae|||%ad|||%cn|||%ce|||%cd --date=format:%Y-%m-%dT%H:%M:%S%z"
+    if commit_sha:
+        cmd += " " + commit_sha
+    stdout = _git_subprocess_cmd(cmd=cmd, cwd=cwd)
     author_name, author_email, author_date, committer_name, committer_email, committer_date = stdout.split("|||")
     return {
         "author": (author_name, author_email, author_date),
@@ -316,6 +345,32 @@ def extract_commit_sha(cwd=None):
     return commit_sha
 
 
+def extract_git_head_metadata(head_commit_sha: str, cwd: Optional[str] = None) -> Dict[str, Optional[str]]:
+    tags: Dict[str, Optional[str]] = {}
+
+    is_shallow, *_ = _is_shallow_repository_with_details(cwd=cwd)
+    if is_shallow:
+        _unshallow_repository(cwd=cwd, repo=None, refspec=None, parent_only=True)
+
+    try:
+        users = extract_user_info(cwd=cwd, commit_sha=head_commit_sha)
+        tags[COMMIT_HEAD_AUTHOR_NAME] = users["author"][0]
+        tags[COMMIT_HEAD_AUTHOR_EMAIL] = users["author"][1]
+        tags[COMMIT_HEAD_AUTHOR_DATE] = users["author"][2]
+        tags[COMMIT_HEAD_COMMITTER_NAME] = users["committer"][0]
+        tags[COMMIT_HEAD_COMMITTER_EMAIL] = users["committer"][1]
+        tags[COMMIT_HEAD_COMMITTER_DATE] = users["committer"][2]
+        tags[COMMIT_HEAD_MESSAGE] = _git_subprocess_cmd(" ".join(("log -n 1 --format=%B", head_commit_sha)), cwd)
+    except GitNotFoundError:
+        log.error("Git executable not found, cannot extract git metadata.")
+    except ValueError as e:
+        debug_mode = log.isEnabledFor(logging.DEBUG)
+        stderr = str(e)
+        log.error("Error extracting git metadata: %s", stderr, exc_info=debug_mode)
+
+    return tags
+
+
 def extract_git_metadata(cwd=None):
     # type: (Optional[str]) -> Dict[str, Optional[str]]
     """Extract git commit metadata."""

ddtrace/internal/_encoding.pyi

@@ -23,7 +23,7 @@ class BufferedEncoder(object):
     def __init__(self, max_size: int, max_item_size: int) -> None: ...
     def __len__(self) -> int: ...
     def put(self, item: Any) -> None: ...
-    def encode(self) -> Tuple[Optional[bytes], int]: ...
+    def encode(self) -> List[Tuple[Optional[bytes], int]]: ...
     @property
     def size(self) -> int: ...