Add retry tracking, tenacity integration, and vendor rename

- Add tenacity integration with contextvars-based retry attempt tracking
- Rename provider to vendor across all attributes and span helpers
- Add event_id and customer_id to RunContext and baggage propagation
- Add OTel LogRecord emission on emit_outcome() for collector flush
- Fix CLIENT_REQUEST_ID -> VENDOR_CLIENT_REQUEST_ID attribute bug
- Remove unused ledger and resource detector modules
- All 296 tests passing

Signed-off-by: Deborah <deborah@botanu.ai>

Author: deborahjacob-botanu

pyproject.toml

@@ -123,17 +123,30 @@ Changelog = "https://github.com/botanu-ai/botanu-sdk-python/blob/main/CHANGELOG.
 Issues = "https://github.com/botanu-ai/botanu-sdk-python/issues"
 
 # ---------------------------------------------------------------------------
-# Optional extras  (dev only — base install includes everything)
+# Optional extras
 # ---------------------------------------------------------------------------
 [project.optional-dependencies]
+# Cloud resource detectors — lightweight, auto-detect env and no-op elsewhere.
+# K8s: use the OTel Operator or K8s downward API to set OTEL_RESOURCE_ATTRIBUTES.
+# EKS/GKE detection is included in the aws/gcp extras respectively.
+aws = ["opentelemetry-resource-detector-aws >= 0.1b0"]
+gcp = ["opentelemetry-resource-detector-gcp >= 0.1b0"]
+azure = ["opentelemetry-resource-detector-azure >= 0.1b0"]
+container = ["opentelemetry-resource-detector-container >= 0.1b0"]
+cloud = [
+    "opentelemetry-resource-detector-aws >= 0.1b0",
+    "opentelemetry-resource-detector-gcp >= 0.1b0",
+    "opentelemetry-resource-detector-azure >= 0.1b0",
+    "opentelemetry-resource-detector-container >= 0.1b0",
+]
 dev = [
     "pytest >= 7.4.0",
     "pytest-asyncio >= 0.21.0",
     "pytest-cov >= 4.1.0",
     "coverage[toml] >= 7.0",
     "httpx >= 0.24.0, < 0.28.0; python_version < '3.10'",
     "httpx >= 0.24.0; python_version >= '3.10'",
-    "starlette >= 0.27.0, < 0.30.0; python_version < '3.10'",
+    "starlette >= 0.27.0, < 0.30.0; python_version >= '3.10'",
     "starlette >= 0.27.0; python_version >= '3.10'",
     "ruff >= 0.4.0",
     "mypy >= 1.7.0",

src/botanu/__init__.py

@@ -5,11 +5,11 @@
 
 Quick Start::
 
-    from botanu import enable, botanu_use_case, emit_outcome
+    from botanu import enable, botanu_workflow, emit_outcome
 
     enable()  # reads config from OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT env vars
 
-    @botanu_use_case(name="Customer Support")
+    @botanu_workflow(name="Customer Support")
     async def handle_request(data):
         result = await process(data)
         emit_outcome("success", value_type="tickets_resolved", value_amount=1)
@@ -38,12 +38,12 @@ async def handle_request(data):
     get_baggage,
     get_current_span,
     get_run_id,
-    get_use_case,
+    get_workflow,
     set_baggage,
 )
 
 # Decorators  (primary integration point)
-from botanu.sdk.decorators import botanu_outcome, botanu_use_case, use_case
+from botanu.sdk.decorators import botanu_outcome, botanu_workflow, run_botanu, workflow
 
 # Span helpers
 from botanu.sdk.span_helpers import emit_outcome, set_business_context
@@ -56,17 +56,18 @@ async def handle_request(data):
     "is_enabled",
     # Configuration
     "BotanuConfig",
-    # Decorators
-    "botanu_use_case",
-    "use_case",
+    # Decorators / context managers
+    "botanu_workflow",
+    "run_botanu",
+    "workflow",
     "botanu_outcome",
     # Span helpers
     "emit_outcome",
     "set_business_context",
     "get_current_span",
     # Context
     "get_run_id",
-    "get_use_case",
+    "get_workflow",
     "set_baggage",
     "get_baggage",
     # Run context

src/botanu/integrations/__init__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2026 The Botanu Authors
+# SPDX-License-Identifier: Apache-2.0
+
+"""Botanu integrations with third-party libraries."""

src/botanu/integrations/tenacity.py

@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: 2026 The Botanu Authors
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tenacity retry integration — automatic attempt tracking for LLM calls.
+
+Stamps ``botanu.request.attempt`` on every span created inside a tenacity
+retry loop so the collector and cost engine can see how many attempts an
+event required.
+
+Usage::
+
+    from tenacity import retry, stop_after_attempt, wait_exponential
+    from botanu.integrations.tenacity import botanu_before, botanu_after_all
+    from botanu.tracking.llm import track_llm_call
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(min=1, max=10),
+        before=botanu_before,
+        after=botanu_after_all,   # optional — resets attempt counter
+    )
+    def call_llm():
+        with track_llm_call("openai", "gpt-4") as tracker:
+            response = openai.chat.completions.create(...)
+            tracker.set_tokens(
+                input_tokens=response.usage.prompt_tokens,
+                output_tokens=response.usage.completion_tokens,
+            )
+            return response
+
+The ``track_llm_call`` context manager reads the attempt number
+automatically — no need to call ``tracker.set_attempt()`` manually.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from botanu.tracking.llm import _retry_attempt
+
+
+def botanu_before(retry_state: Any) -> None:
+    """Tenacity ``before`` callback — sets the current attempt number.
+
+    Use as ``@retry(before=botanu_before)`` so that every
+    ``track_llm_call`` inside the retried function automatically
+    gets the correct attempt number on its span.
+    """
+    _retry_attempt.set(retry_state.attempt_number)
+
+
+def botanu_after_all(retry_state: Any) -> None:
+    """Tenacity ``after`` callback — resets the attempt counter.
+
+    Optional but recommended. Prevents a stale attempt number from
+    leaking into subsequent non-retried calls on the same thread.
+
+    Use as ``@retry(after=botanu_after_all)``.
+    """
+    _retry_attempt.set(0)

src/botanu/models/run_context.py

@@ -5,7 +5,7 @@
 
 A "Run" is orthogonal to tracing:
 - Trace context (W3C): ties distributed spans together (trace_id, span_id)
-- Run context (Botanu): ties business execution together (run_id, use_case, outcome)
+- Run context (Botanu): ties business execution together (run_id, workflow, outcome)
 
 Invariant: A run can span multiple traces (retries, async fanout).
 The run_id must remain stable across those boundaries.
@@ -85,9 +85,10 @@ class RunContext:
     """
 
     run_id: str
-    use_case: str
+    workflow: str
+    event_id: str
+    customer_id: str
     environment: str
-    workflow: Optional[str] = None
     workflow_version: Optional[str] = None
     tenant_id: Optional[str] = None
     parent_run_id: Optional[str] = None
@@ -111,8 +112,9 @@ def __post_init__(self) -> None:
     @classmethod
     def create(
         cls,
-        use_case: str,
-        workflow: Optional[str] = None,
+        workflow: str,
+        event_id: str,
+        customer_id: str,
         workflow_version: Optional[str] = None,
         environment: Optional[str] = None,
         tenant_id: Optional[str] = None,
@@ -131,9 +133,10 @@ def create(
 
         return cls(
             run_id=run_id,
-            use_case=use_case,
-            environment=env,
             workflow=workflow,
+            event_id=event_id,
+            customer_id=customer_id,
+            environment=env,
             workflow_version=workflow_version,
             tenant_id=tenant_id,
             parent_run_id=parent_run_id,
@@ -147,8 +150,9 @@ def create(
     def create_retry(cls, previous: RunContext) -> RunContext:
         """Create a new RunContext for a retry attempt."""
         return cls.create(
-            use_case=previous.use_case,
             workflow=previous.workflow,
+            event_id=previous.event_id,
+            customer_id=previous.customer_id,
             workflow_version=previous.workflow_version,
             environment=previous.environment,
             tenant_id=previous.tenant_id,
@@ -215,14 +219,14 @@ def to_baggage_dict(self, lean_mode: Optional[bool] = None) -> Dict[str, str]:
 
         baggage: Dict[str, str] = {
             "botanu.run_id": self.run_id,
-            "botanu.use_case": self.use_case,
+            "botanu.workflow": self.workflow,
+            "botanu.event_id": self.event_id,
+            "botanu.customer_id": self.customer_id,
         }
         if lean_mode:
             return baggage
 
         baggage["botanu.environment"] = self.environment
-        if self.workflow:
-            baggage["botanu.workflow"] = self.workflow
         if self.tenant_id:
             baggage["botanu.tenant_id"] = self.tenant_id
         if self.parent_run_id:
@@ -243,12 +247,12 @@ def to_span_attributes(self) -> Dict[str, Union[str, float, int, bool]]:
         """Convert to dict for span attributes."""
         attrs: Dict[str, Union[str, float, int, bool]] = {
             "botanu.run_id": self.run_id,
-            "botanu.use_case": self.use_case,
+            "botanu.workflow": self.workflow,
+            "botanu.event_id": self.event_id,
+            "botanu.customer_id": self.customer_id,
             "botanu.environment": self.environment,
             "botanu.run.start_time": self.start_time.isoformat(),
         }
-        if self.workflow:
-            attrs["botanu.workflow"] = self.workflow
         if self.workflow_version:
             attrs["botanu.workflow.version"] = self.workflow_version
         if self.tenant_id:
@@ -285,8 +289,8 @@ def to_span_attributes(self) -> Dict[str, Union[str, float, int, bool]]:
     def from_baggage(cls, baggage: Dict[str, str]) -> Optional[RunContext]:
         """Reconstruct RunContext from baggage dict."""
         run_id = baggage.get("botanu.run_id")
-        use_case = baggage.get("botanu.use_case")
-        if not run_id or not use_case:
+        workflow = baggage.get("botanu.workflow")
+        if not run_id or not workflow:
             return None
 
         attempt_str = baggage.get("botanu.attempt", "1")
@@ -305,11 +309,15 @@ def from_baggage(cls, baggage: Dict[str, str]) -> Optional[RunContext]:
 
         cancelled = baggage.get("botanu.cancelled", "").lower() == "true"
 
+        event_id = baggage.get("botanu.event_id", "")
+        customer_id = baggage.get("botanu.customer_id", "")
+
         return cls(
             run_id=run_id,
-            use_case=use_case,
+            workflow=workflow,
+            event_id=event_id,
+            customer_id=customer_id,
             environment=baggage.get("botanu.environment", "unknown"),
-            workflow=baggage.get("botanu.workflow"),
             tenant_id=baggage.get("botanu.tenant_id"),
             parent_run_id=baggage.get("botanu.parent_run_id"),
             root_run_id=baggage.get("botanu.root_run_id") or run_id,

src/botanu/processors/enricher.py

@@ -30,27 +30,30 @@ class RunContextEnricher(SpanProcessor):
     """Enriches ALL spans with run context from baggage.
 
     This ensures that every span (including auto-instrumented ones)
-    gets ``botanu.run_id``, ``botanu.use_case``, etc. attributes.
+    gets ``botanu.run_id``, ``botanu.workflow``, etc. attributes.
 
     Without this processor, only the root ``botanu.run`` span would
     have these attributes.
 
-    In ``lean_mode`` (default), only ``run_id`` and ``use_case`` are
+    In ``lean_mode`` (default), only ``run_id`` and ``workflow`` are
     propagated to minimise per-span overhead.
     """
 
     BAGGAGE_KEYS_FULL: ClassVar[List[str]] = [
         "botanu.run_id",
-        "botanu.use_case",
         "botanu.workflow",
+        "botanu.event_id",
+        "botanu.customer_id",
         "botanu.environment",
         "botanu.tenant_id",
         "botanu.parent_run_id",
     ]
 
     BAGGAGE_KEYS_LEAN: ClassVar[List[str]] = [
         "botanu.run_id",
-        "botanu.use_case",
+        "botanu.workflow",
+        "botanu.event_id",
+        "botanu.customer_id",
     ]
 
     def __init__(self, lean_mode: bool = True) -> None:

src/botanu/resources/__init__.py

@@ -1,8 +1,87 @@
 # SPDX-FileCopyrightText: 2026 The Botanu Authors
 # SPDX-License-Identifier: Apache-2.0
 
-"""Botanu resource detection."""
+"""Resource detection using official OTel community detectors.
 
-from botanu.resources.detector import detect_all_resources, get_resource_attributes
+Instead of a custom reimplementation, we try to import the official
+OpenTelemetry resource detector packages.  Each one is a lightweight
+pip package that auto-detects environment attributes (K8s, AWS, GCP,
+Azure, container).  If a package isn't installed, we gracefully skip it.
 
-__all__ = ["detect_all_resources", "get_resource_attributes"]
+Install detectors for your environment::
+
+    pip install botanu[aws]       # AWS EC2/ECS/EKS/Lambda
+    pip install botanu[gcp]       # GCE/GKE/Cloud Run/Cloud Functions
+    pip install botanu[azure]     # Azure VMs/App Service/Functions
+    pip install botanu[cloud]     # All cloud detectors
+"""
+
+from __future__ import annotations
+
+import importlib
+import logging
+from typing import Any, Dict, List, Tuple
+
+logger = logging.getLogger(__name__)
+
+# (module_path, class_name) — tried in order.
+# Each entry corresponds to a pip package from opentelemetry-python-contrib.
+_DETECTOR_REGISTRY: List[Tuple[str, str]] = [
+    # Built-in (opentelemetry-sdk — always available)
+    ("opentelemetry.sdk.resources", "ProcessResourceDetector"),
+    # opentelemetry-resource-detector-aws
+    ("opentelemetry.resource.detector.aws.ec2", "AwsEc2ResourceDetector"),
+    ("opentelemetry.resource.detector.aws.ecs", "AwsEcsResourceDetector"),
+    ("opentelemetry.resource.detector.aws.eks", "AwsEksResourceDetector"),
+    ("opentelemetry.resource.detector.aws.lambda_", "AwsLambdaResourceDetector"),
+    # opentelemetry-resource-detector-gcp
+    ("opentelemetry.resource.detector.gcp", "GoogleCloudResourceDetector"),
+    # opentelemetry-resource-detector-azure
+    ("opentelemetry.resource.detector.azure.vm", "AzureVMResourceDetector"),
+    ("opentelemetry.resource.detector.azure.app_service", "AzureAppServiceResourceDetector"),
+    # opentelemetry-resource-detector-container
+    ("opentelemetry.resource.detector.container", "ContainerResourceDetector"),
+]
+
+
+def collect_detectors() -> list:
+    """Return instances of all importable OTel resource detectors.
+
+    Each detector implements ``opentelemetry.sdk.resources.ResourceDetector``.
+    Missing packages are silently skipped.
+    """
+    detectors: list = []
+    for module_path, class_name in _DETECTOR_REGISTRY:
+        try:
+            mod = importlib.import_module(module_path)
+            cls = getattr(mod, class_name)
+            detectors.append(cls())
+        except (ImportError, AttributeError):
+            pass
+
+    if detectors:
+        names = [type(d).__name__ for d in detectors]
+        logger.debug("Available resource detectors: %s", names)
+
+    return detectors
+
+
+def detect_resource_attrs() -> Dict[str, Any]:
+    """Detect environment attributes using available OTel detectors.
+
+    Returns a flat dict of resource attributes.  This is a convenience
+    wrapper for callers that just need a dict (like bootstrap.py).
+    """
+    attrs: Dict[str, Any] = {}
+    for detector in collect_detectors():
+        try:
+            resource = detector.detect()
+            attrs.update(dict(resource.attributes))
+        except Exception:
+            # Community detectors may raise on network timeouts, missing
+            # metadata endpoints, etc.  Never let detection break SDK init.
+            logger.debug("Resource detector %s failed", type(detector).__name__, exc_info=True)
+    return attrs
+
+
+__all__ = ["collect_detectors", "detect_resource_attrs"]