odigos-agentcore 0.0.25__tar.gz

odigos_agentcore-0.0.25/.gitignore

@@ -0,0 +1,57 @@
+# Build output: layer zips extracted from the image, per-region publish results, rendered manifests.
+# Never commit a layer zip here — lambda/layers/ is the one place an override belongs.
+dist/
+
+# Node / CDK build output. cdk/tsconfig.json is generated by jsii on every build (see cdk/.gitignore).
+node_modules/
+
+# Python bytecode from the AgentCore builder and bootstrap tests.
+__pycache__/
+*.pyc
+
+.DS_Store
+
+# Local .terraform directories
+.terraform/
+
+# .tfstate files
+*.tfstate
+*.tfstate.*
+
+# Crash log files
+crash.log
+crash.*.log
+
+# Exclude all .tfvars files, which are likely to contain sensitive data, such as
+# password, private keys, and other secrets. These should not be part of version
+# control as they are data points which are potentially sensitive and subject
+# to change depending on the environment.
+*.tfvars
+*.tfvars.json
+
+# Ignore override files as they are usually used to override resources locally and so
+# are not checked in
+override.tf
+override.tf.json
+*_override.tf
+*_override.tf.json
+
+# Ignore transient lock info files created by terraform apply
+.terraform.tfstate.lock.info
+
+# Include override files you do wish to add to version control using negated pattern
+# !example_override.tf
+
+# Include tfplan files to ignore the plan output of command: terraform plan -out=tfplan
+# example: *tfplan*
+
+# Ignore CLI configuration files
+.terraformrc
+terraform.rc
+
+# Optional: ignore graph output files generated by `terraform graph`
+# *.dot
+
+# Optional: ignore plan files saved before destroying Terraform configuration
+# Uncomment the line below if you want to ignore planout files.
+# planout

odigos_agentcore-0.0.25/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.5
+Name: odigos-agentcore
+Version: 0.0.25
+Summary: Odigos OpenTelemetry bootstrap for Amazon Bedrock AgentCore Runtime agents
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Provides-Extra: adot
+Requires-Dist: aws-opentelemetry-distro==0.21.0; extra == 'adot'
+Provides-Extra: openllmetry
+Requires-Dist: opentelemetry-distro==0.66b1; extra == 'openllmetry'
+Requires-Dist: opentelemetry-exporter-otlp-proto-http==1.45.1; extra == 'openllmetry'
+Requires-Dist: opentelemetry-instrumentation-aiohttp-client==0.66b1; extra == 'openllmetry'
+Requires-Dist: opentelemetry-instrumentation-asgi==0.66b1; extra == 'openllmetry'
+Requires-Dist: opentelemetry-instrumentation-bedrock==0.62.3; extra == 'openllmetry'
+Requires-Dist: opentelemetry-instrumentation-fastapi==0.66b1; extra == 'openllmetry'
+Requires-Dist: opentelemetry-instrumentation-httpx==0.66b1; extra == 'openllmetry'
+Requires-Dist: opentelemetry-instrumentation-logging==0.66b1; extra == 'openllmetry'
+Requires-Dist: opentelemetry-instrumentation-requests==0.66b1; extra == 'openllmetry'
+Requires-Dist: opentelemetry-instrumentation-starlette==0.66b1; extra == 'openllmetry'
+Requires-Dist: opentelemetry-instrumentation-threading==0.66b1; extra == 'openllmetry'
+Requires-Dist: opentelemetry-instrumentation-urllib3==0.66b1; extra == 'openllmetry'
+Requires-Dist: opentelemetry-propagator-aws-xray==1.0.2; extra == 'openllmetry'
+Requires-Dist: opentelemetry-sdk==1.45.1; extra == 'openllmetry'

odigos_agentcore-0.0.25/odigos_agentcore/__init__.py

@@ -0,0 +1 @@
+"""Odigos AgentCore bootstrap. Dormant unless the runtime sets ODIGOS_AGENTCORE_ENABLED=true; see bootstrap.py."""

odigos_agentcore-0.0.25/odigos_agentcore/_autostart.py

@@ -0,0 +1,4 @@
+"""Imported by odigos_agentcore.pth when the interpreter processes the site-packages the package is installed into."""
+from odigos_agentcore.bootstrap import start
+
+start()

odigos_agentcore-0.0.25/odigos_agentcore/bootstrap.py

@@ -0,0 +1,202 @@
+"""Odigos AgentCore bootstrap: starts the selected OpenTelemetry profile, then adjusts its telemetry for AgentCore.
+
+One copy of this code serves every delivery:
+
+- the wheel's ``odigos_agentcore.pth``, which imports it at interpreter start in the environment the package is
+  installed into (container images);
+- ``odigos_agentcore/startup/sitecustomize.py``, which ``odigos_agentcore_start.py`` puts on ``PYTHONPATH`` when the
+  package was installed into a direct-code ZIP with ``pip install --target``;
+- the prepared bundle's ``bootstrap/python/sitecustomize.py`` (the carrier image layout), which passes the bundle
+  root so the profile is taken from ``<root>/profiles/python/<vendor>``.
+
+Everything stays dormant unless ``ODIGOS_AGENTCORE_ENABLED=true``. This module imports only what the interpreter
+has already loaded until then, so the dormant cost is one environment lookup.
+"""
+import os
+import sys
+
+PROFILES = {"python-agentcore-adot": "adot", "python-agentcore-openllmetry": "openllmetry"}
+# A module each profile's SDK installs; how a profile is found in the environment the package is installed into.
+PROFILE_MODULES = {"adot": "amazon.opentelemetry.distro", "openllmetry": "opentelemetry.instrumentation.bedrock"}
+
+_initialized = False
+
+
+def start(root=None):
+    """Initialize, failing open: an error is reported by type only and never reaches the application."""
+    try:
+        initialize(root)
+    except Exception as error:
+        # Fail open for business traffic. Emit no environment, request content or exception text.
+        sys.stderr.write("Odigos AgentCore instrumentation failed to initialize (" + type(error).__name__ + ").\n")
+
+
+def initialize(root=None):
+    """Start the profile ODIGOS_AGENTCORE_DISTRO selects. ``root`` is a prepared bundle's root, or None."""
+    global _initialized
+    if os.environ.get("ODIGOS_AGENTCORE_ENABLED", "").lower() != "true" or _initialized:
+        return
+    vendor = PROFILES.get(os.environ.get("ODIGOS_AGENTCORE_DISTRO", ""))
+    if vendor is None:
+        raise RuntimeError("unsupported Odigos AgentCore Python profile")
+    select_profile(vendor, root)
+    # Set before the SDK starts: a second entry point in the same process (the .pth and a bundle's sitecustomize)
+    # must not instrument again, even after a partial failure.
+    _initialized = True
+    os.environ["OTEL_PYTHON_DISTRO"] = "aws_distro" if vendor == "adot" else "distro"
+    os.environ["OTEL_PYTHON_CONFIGURATOR"] = "aws_configurator" if vendor == "adot" else "configurator"
+    os.environ["TRACELOOP_TRACE_CONTENT"] = "false"
+    os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = "false"
+    from opentelemetry.instrumentation.auto_instrumentation import initialize as instrument
+    instrument()
+    suppress_contentless_genai_events()
+    redact_genai_content()
+    exclude_asgi_message_spans()
+    root_invocations_at_the_agent()
+
+
+def select_profile(vendor, root=None):
+    """Make the selected profile importable; return the directory put on sys.path, or None for the environment.
+
+    A prepared bundle carries each profile at ``<root>/profiles/python/<vendor>``; only the selected one joins
+    sys.path, so only it takes part in imports and entry-point discovery. Without that directory the profile is
+    the SDK the package's extra installed next to it. Raises when neither is present.
+    """
+    if root is not None:
+        packages = os.path.join(str(root), "profiles", "python", vendor)
+        if os.path.isdir(packages):
+            if not os.path.isdir(os.path.join(packages, "opentelemetry")):
+                raise RuntimeError("selected Odigos AgentCore profile is not packaged")
+            sys.path.insert(0, packages)
+            return packages
+    if not installed(PROFILE_MODULES[vendor]):
+        raise RuntimeError("selected Odigos AgentCore profile is not installed")
+    return None
+
+
+def installed(module):
+    from importlib.util import find_spec
+    try:
+        return find_spec(module) is not None
+    except (ImportError, ValueError):  # A missing parent package raises instead of returning None.
+        return False
+
+
+def suppress_contentless_genai_events():
+    # Content capture is always off here, yet botocore's Bedrock instrumentation still emits one GenAI event
+    # per prompt message and model choice with the content removed: hundreds of bodiless log records per
+    # agent run. The model spans already carry model, token usage and finish reasons, so those emitters get
+    # a no-op logger. They create loggers on first use from the global provider, which exists by now.
+    from opentelemetry._logs import NoOpLogger, get_logger_provider
+    provider = get_logger_provider()
+    original = provider.get_logger
+
+    def get_logger(name, *args, **kwargs):
+        if name.startswith("opentelemetry.instrumentation.botocore.bedrock"):
+            return NoOpLogger(name)
+        return original(name, *args, **kwargs)
+    provider.get_logger = get_logger
+
+
+# GenAI span attributes and span events that carry prompt, response, instruction or tool payload text.
+CONTENT_ATTRIBUTES = frozenset({
+    "gen_ai.input.messages", "gen_ai.output.messages", "gen_ai.system_instructions",
+    "gen_ai.tool.call.arguments", "gen_ai.tool.call.result", "gen_ai.prompt", "gen_ai.completion",
+})
+CONTENT_ATTRIBUTE_PREFIXES = ("gen_ai.prompt.", "gen_ai.completion.")
+CONTENT_EVENTS = frozenset({"gen_ai.choice", "gen_ai.client.inference.operation.details"})
+
+
+def is_content_attribute(key):
+    return key in CONTENT_ATTRIBUTES or key.startswith(CONTENT_ATTRIBUTE_PREFIXES)
+
+
+def is_content_event(name):
+    return name in CONTENT_EVENTS or (name.startswith("gen_ai.") and name.endswith(".message"))
+
+
+def redact_genai_content():
+    # Content capture is off, yet some frameworks record content regardless: ADOT's LangChain instrumentation
+    # writes prompts, responses and tool payloads as span attributes without consulting
+    # OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT, and Strands' own tracer always adds the conversation as
+    # span events. Both are removed from every span as it ends, before any exporter receives it. The SDK freezes
+    # a span's attributes just before this hook runs, so they are unfrozen only to remove the content keys.
+    from opentelemetry import trace
+    from opentelemetry.sdk.trace import SpanProcessor
+
+    provider = trace.get_tracer_provider()
+    if not hasattr(provider, "add_span_processor"):
+        return
+
+    class GenAIContentRedaction(SpanProcessor):
+        def _on_ending(self, span):
+            try:
+                attributes = span._attributes
+                content = [key for key in attributes if is_content_attribute(key)]
+                if content:
+                    attributes._immutable = False
+                    try:
+                        for key in content:
+                            del attributes[key]
+                    finally:
+                        attributes._immutable = True
+                events = span._events
+                for event in [event for event in events if is_content_event(event.name)]:
+                    events._dq.remove(event)
+            except Exception:
+                pass
+
+    provider.add_span_processor(GenAIContentRedaction())
+
+
+def exclude_asgi_message_spans():
+    # The ASGI middleware adds an internal span for every message it sends or receives (response start, each
+    # body chunk, request body), several per request, each repeating the server span's name. The Starlette and
+    # FastAPI instrumentations expose no setting for this, so the middleware's own option becomes the default.
+    # The module is loaded only when an ASGI framework instrumentation was installed.
+    asgi = sys.modules.get("opentelemetry.instrumentation.asgi")
+    if asgi is None:
+        return
+    middleware = asgi.OpenTelemetryMiddleware
+    original = middleware.__init__
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("exclude_spans", ["receive", "send"])
+        original(self, *args, **kwargs)
+    middleware.__init__ = __init__
+
+
+def root_invocations_at_the_agent(environ=None):
+    # Every request reaches the agent through the AgentCore data plane, which replaces the caller's span with
+    # one of its own (in both traceparent and X-Amzn-Trace-Id) and exports that span only to X-Ray. Left as
+    # the parent, it is a span no backend receives. The agent's server span becomes the root instead: it keeps
+    # the trace ID, so an instrumented caller's trace still groups with the agent's, and links to AgentCore's
+    # span. AgentCore's session ID arrives as baggage and is recorded on the root. Returns whether it was installed:
+    # ODIGOS_AGENTCORE_ROOT_INVOCATIONS=false keeps AgentCore's parent, for backends that also ingest its spans.
+    environ = os.environ if environ is None else environ
+    if environ.get("ODIGOS_AGENTCORE_ROOT_INVOCATIONS", "true").lower() == "false":
+        return False
+    from opentelemetry import baggage, trace
+    from opentelemetry.sdk.trace import SpanProcessor
+    from opentelemetry.trace import SpanKind
+
+    provider = trace.get_tracer_provider()
+    if not hasattr(provider, "add_span_processor"):
+        return False
+
+    class AgentCoreInvocationRoot(SpanProcessor):
+        def on_start(self, span, parent_context=None):
+            try:
+                parent = span.parent
+                if span.kind != SpanKind.SERVER or parent is None or not parent.is_remote or not hasattr(span, "_parent"):
+                    return
+                span._parent = None
+                span.add_link(parent, {"odigos.link.reason": "agentcore_invocation"})
+                session = baggage.get_baggage("session.id", parent_context)
+                if session:
+                    span.set_attribute("session.id", str(session))
+            except Exception:
+                pass  # Fail open: the span keeps AgentCore's parent.
+
+    provider.add_span_processor(AgentCoreInvocationRoot())
+    return True

odigos_agentcore-0.0.25/odigos_agentcore/startup/sitecustomize.py

@@ -0,0 +1,9 @@
+"""Dormant loader for the package installed into a direct-code ZIP (``pip install --target``).
+
+A ZIP root is not a site directory, so ``odigos_agentcore.pth`` is not processed there. ``odigos_agentcore_start.py``
+puts this directory first on ``PYTHONPATH`` and the ZIP root after it; Python imports this module at interpreter start,
+before the application's own imports.
+"""
+from odigos_agentcore.bootstrap import start
+
+start()

odigos_agentcore-0.0.25/odigos_agentcore.pth

@@ -0,0 +1 @@
+import odigos_agentcore._autostart

odigos_agentcore-0.0.25/odigos_agentcore_start.py

@@ -0,0 +1,51 @@
+"""Start a direct-code AgentCore application with the Odigos bootstrap.
+
+Make this file the runtime's entry point followed by the original one: ["odigos_agentcore_start.py", "app.py",
+<original arguments>]. It finds the bootstrap relative to its own file, in any of these layouts:
+
+- installed by ``pip install --target <zip root> odigos-agentcore[...]``: this module and the odigos_agentcore package
+  sit at the ZIP root;
+- copied to the ZIP root next to a prepared odigos-agentcore/ bundle;
+- used in place inside that bundle, as odigos-agentcore/bootstrap/python/odigos_agentcore_start.py.
+
+The bootstrap stays dormant unless the runtime environment enables it, so the same ZIP runs uninstrumented too.
+"""
+import os
+import sys
+from pathlib import Path
+
+
+def locate(here):
+    """Return (ZIP root, directory holding the sitecustomize that loads the bootstrap), or None."""
+    bundle = here / "odigos-agentcore" / "bootstrap" / "python"
+    if bundle.is_dir():
+        return here, bundle
+    if here.parent.name == "bootstrap" and (here / "sitecustomize.py").is_file():
+        return here.parents[2], here
+    startup = here / "odigos_agentcore" / "startup"
+    if (startup / "sitecustomize.py").is_file():
+        return here, startup
+    return None
+
+
+def main():
+    found = locate(Path(__file__).resolve().parent)
+    if found is None:
+        sys.stderr.write("odigos_agentcore_start.py: the Odigos AgentCore bootstrap is not next to this file.\n")
+        sys.exit(2)
+    root, bootstrap = found
+    if len(sys.argv) < 2:
+        sys.stderr.write("odigos_agentcore_start.py: pass the application's entry point as the next entry point element.\n")
+        sys.exit(2)
+    entry = root / sys.argv[1]
+    # sitecustomize runs at interpreter start, before Python adds the script's own directory to sys.path. The root
+    # follows it: the package layout imports odigos_agentcore and the SDK from there.
+    paths = [str(bootstrap), str(entry.parent), str(root)]
+    if os.environ.get("PYTHONPATH"):
+        paths.append(os.environ["PYTHONPATH"])
+    os.environ["PYTHONPATH"] = os.pathsep.join(dict.fromkeys(paths))
+    os.execv(sys.executable, [sys.executable, str(entry), *sys.argv[2:]])
+
+
+if __name__ == "__main__":
+    main()

odigos_agentcore-0.0.25/pyproject.toml

@@ -0,0 +1,48 @@
+# Generated by agentcore/render_packages.py from versions.env and artifacts.json; do not edit.
+#
+# The wheel ships the odigos_agentcore package, the odigos_agentcore_start.py ZIP wrapper and odigos_agentcore.pth at
+# its root. sitecustomize.py in this directory is the prepared bundle's loader and is not part of the wheel.
+
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "odigos-agentcore"
+version = "0.0.25"
+description = "Odigos OpenTelemetry bootstrap for Amazon Bedrock AgentCore Runtime agents"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+dependencies = []
+
+# One extra per profile; the installed extra must match the distro the runtime selects.
+[project.optional-dependencies]
+adot = [
+  "aws-opentelemetry-distro==0.21.0",
+]
+openllmetry = [
+  "opentelemetry-distro==0.66b1",
+  "opentelemetry-sdk==1.45.1",
+  "opentelemetry-exporter-otlp-proto-http==1.45.1",
+  "opentelemetry-instrumentation-bedrock==0.62.3",
+  "opentelemetry-propagator-aws-xray==1.0.2",
+  "opentelemetry-instrumentation-asgi==0.66b1",
+  "opentelemetry-instrumentation-starlette==0.66b1",
+  "opentelemetry-instrumentation-fastapi==0.66b1",
+  "opentelemetry-instrumentation-aiohttp-client==0.66b1",
+  "opentelemetry-instrumentation-httpx==0.66b1",
+  "opentelemetry-instrumentation-requests==0.66b1",
+  "opentelemetry-instrumentation-urllib3==0.66b1",
+  "opentelemetry-instrumentation-logging==0.66b1",
+  "opentelemetry-instrumentation-threading==0.66b1",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["odigos_agentcore"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"odigos_agentcore.pth" = "odigos_agentcore.pth"
+"odigos_agentcore_start.py" = "odigos_agentcore_start.py"
+
+[tool.hatch.build.targets.sdist]
+include = ["odigos_agentcore", "odigos_agentcore.pth", "odigos_agentcore_start.py", "pyproject.toml"]