thothctl 0.14.2__tar.gz → 0.14.4__tar.gz

{thothctl-0.14.2 → thothctl-0.14.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thothctl
-Version: 0.14.2
+Version: 0.14.4
 Summary: A CLI for Developer Control Plane. Accelerate your cloud IaC deployments.
 Project-URL: Homepage, https://github.com/thothforge/thothctl
 Author-email: Alejandro Velez <velez94@pm.me>

{thothctl-0.14.2 → thothctl-0.14.4}/docs/framework/commands/inventory/CHANGELOG.md

@@ -1,5 +1,14 @@
 # ThothCTL Inventory Command Changelog
 
+## Version 0.14.3 - May 2026
+
+### 🔧 Fix: Weighted Technical Debt Scoring
+
+- **Weighted formula**: Modules now carry 70% weight and providers 30% in debt score calculation
+- **Fairer scoring**: A single outdated provider no longer inflates the score disproportionately
+- **Consistent thresholds**: CDK risk levels aligned with the main formula (70/50/30)
+- **Rationale**: Providers may be intentionally pinned (e.g., a module tested against a specific provider version), so they should not dominate the debt score
+
 ## Version 0.4.0 - July 2025
 
 ### 🎯 Major Improvements

{thothctl-0.14.2 → thothctl-0.14.4}/docs/framework/commands/inventory/inventory_iac.md

@@ -197,6 +197,52 @@ The reports now include comprehensive provider data:
 - **Module Context**: Which module uses the provider
 - **Status**: Current, Outdated, or Unknown
 
+## Technical Debt Scoring 📊
+
+When `--check-versions` is enabled, ThothCTL calculates a **technical debt score** that reflects how outdated your infrastructure is.
+
+### Weighted Formula
+
+The debt score uses a weighted approach that separates module health from provider health:
+
+```
+module_debt   = outdated_modules / total_modules       (weight: 70%)
+provider_debt = outdated_providers / total_providers   (weight: 30%)
+
+debt_score = (module_debt × 0.7 + provider_debt × 0.3) × 100 + breaking_changes_penalty
+```
+
+**Why weighted?** Modules define your architecture and are the primary source of risk. Providers are dependencies that may be intentionally pinned (e.g., a latest module tested against a specific provider version). A single outdated provider should not inflate the score disproportionately.
+
+### Breaking Changes Penalty
+
+Each module or provider with detected breaking changes adds **+5 points** to the debt score (capped at 100%).
+
+### Risk Levels
+
+| Debt Score | Risk Level | Meaning |
+|-----------|------------|---------|
+| ≥ 70%    | **Critical** | Immediate action required |
+| ≥ 50%    | **High** | Plan upgrades soon |
+| ≥ 30%    | **Medium** | Schedule maintenance |
+| < 30%    | **Low** | Infrastructure is well-maintained |
+
+### Examples
+
+| Scenario | Score | Risk |
+|----------|-------|------|
+| 2 modules current, 1/2 providers outdated | 15% | Low |
+| 2/4 modules outdated, providers current | 35% | Medium |
+| All modules and providers outdated | 100% | Critical |
+| Everything current | 0% | Low |
+
+### Recommendations
+
+The system auto-generates actionable recommendations based on the metrics:
+- Update outdated modules/providers
+- Review components with breaking changes before upgrading
+- Confirmation when infrastructure is well-maintained (score < 20%)
+
 ## Framework Type Options
 
 ### Auto-detect Framework (Default)

{thothctl-0.14.2 → thothctl-0.14.4}/src/thothctl/services/ai_review/ai_agent.py

@@ -20,6 +20,7 @@ from .utils.prompts import (
     SYSTEM_FULL_ANALYSIS,
 )
 from .utils.fix_prompts import SYSTEM_FIX_GENERATOR
+from .tracing import span
 
 logger = logging.getLogger(__name__)
 
@@ -82,35 +83,37 @@ class AIReviewAgent:
         Calls InventoryService, ScanService, BlastRadiusService, and collects
         raw code to give the LLM a complete picture of the IaC project.
         """
-        logger.info(f"Building rich context for {directory}")
-        ctx = self.context_builder.build_context(directory)
-
-        # If we got scan results through context building, compute basic risk
-        basic_risk = None
-        if ctx.scan_results.get("total_findings", 0) > 0:
-            basic_risk = self.risk_assessor.assess_risk(ctx.scan_results)
-
-        if not self.cost_tracker.check_budget():
-            logger.warning("Budget limit reached")
-            if basic_risk:
-                return self._basic_analysis(ctx.scan_results, basic_risk)
-            return self._empty_result()
-
-        formatted = self.context_builder.format_for_ai(ctx)
-        fallback = (lambda: self._basic_analysis(ctx.scan_results, basic_risk)) if basic_risk else self._empty_result
-        result = self._call_ai(SYSTEM_FULL_ANALYSIS, formatted, "analyze_directory", fallback=fallback)
-
-        # Attach context metadata so callers know what was collected
-        result["_context"] = {
-            "project_type": ctx.project_type,
-            "modules_found": len(ctx.modules),
-            "providers_found": len(ctx.providers),
-            "scan_findings": ctx.scan_results.get("total_findings", 0),
-            "blast_radius_components": ctx.blast_radius.get("total_components", 0),
-            "code_files": len(ctx.code_files),
-            "collection_notes": ctx.errors,
-        }
-        return result
+        with span("ai_agent.analyze_directory", {"directory": directory}) as s:
+            logger.info(f"Building rich context for {directory}")
+            ctx = self.context_builder.build_context(directory)
+
+            basic_risk = None
+            if ctx.scan_results.get("total_findings", 0) > 0:
+                basic_risk = self.risk_assessor.assess_risk(ctx.scan_results)
+
+            if not self.cost_tracker.check_budget():
+                logger.warning("Budget limit reached")
+                s.set_attribute("budget_exceeded", True)
+                if basic_risk:
+                    return self._basic_analysis(ctx.scan_results, basic_risk)
+                return self._empty_result()
+
+            formatted = self.context_builder.format_for_ai(ctx)
+            fallback = (lambda: self._basic_analysis(ctx.scan_results, basic_risk)) if basic_risk else self._empty_result
+            result = self._call_ai(SYSTEM_FULL_ANALYSIS, formatted, "analyze_directory", fallback=fallback)
+
+            result["_context"] = {
+                "project_type": ctx.project_type,
+                "modules_found": len(ctx.modules),
+                "providers_found": len(ctx.providers),
+                "scan_findings": ctx.scan_results.get("total_findings", 0),
+                "blast_radius_components": ctx.blast_radius.get("total_components", 0),
+                "code_files": len(ctx.code_files),
+                "collection_notes": ctx.errors,
+            }
+            s.set_attribute("findings", ctx.scan_results.get("total_findings", 0))
+            s.set_attribute("code_files", len(ctx.code_files))
+            return result
 
     def review_code(self, directory: str) -> Dict[str, Any]:
         """Review raw IaC code with AI (no thothctl service context)."""
@@ -129,38 +132,31 @@ class AIReviewAgent:
 
     def generate_fixes(self, directory: str, scan_results: Dict = None,
                        severity_filter: str = None) -> Dict[str, Any]:
-        """Generate actionable code fixes for scan findings.
+        """Generate actionable code fixes for scan findings."""
+        with span("ai_agent.generate_fixes", {"directory": directory, "severity_filter": severity_filter or "all"}) as s:
+            if not scan_results:
+                analyzer = ReportAnalyzer()
+                reports_dir = Path(directory) / "Reports"
+                if reports_dir.exists():
+                    scan_results = analyzer.parse_scan_results(str(reports_dir))
+                else:
+                    analysis = self.analyze_directory(directory)
+                    return self._fixes_from_analysis(analysis, directory)
 
-        Args:
-            directory: Path to IaC code
-            scan_results: Pre-parsed scan results (or auto-collected)
-            severity_filter: Only fix findings at this severity or above
-        """
-        # Collect scan results if not provided
-        if not scan_results:
-            analyzer = ReportAnalyzer()
-            reports_dir = Path(directory) / "Reports"
-            if reports_dir.exists():
-                scan_results = analyzer.parse_scan_results(str(reports_dir))
-            else:
-                # Run analysis to get findings
-                analysis = self.analyze_directory(directory)
-                return self._fixes_from_analysis(analysis, directory)
-
-        if scan_results.get("total_findings", 0) == 0:
-            return {"fixes": [], "skipped": [], "summary": {"total_findings": 0, "fixes_generated": 0, "skipped": 0}}
-
-        # Collect affected code files
-        code_files = self.code_reviewer.collect_code_for_review(directory)
+            if scan_results.get("total_findings", 0) == 0:
+                return {"fixes": [], "skipped": [], "summary": {"total_findings": 0, "fixes_generated": 0, "skipped": 0}}
 
-        if not self.cost_tracker.check_budget():
-            return self._pattern_fixes(scan_results, code_files, severity_filter)
+            code_files = self.code_reviewer.collect_code_for_review(directory)
+
+            if not self.cost_tracker.check_budget():
+                s.set_attribute("fallback", "pattern_fixes")
+                return self._pattern_fixes(scan_results, code_files, severity_filter)
 
-        # Build prompt with findings + code
-        content = self._format_fix_request(scan_results, code_files, severity_filter)
-        result = self._call_ai(SYSTEM_FIX_GENERATOR, content, "generate_fixes",
-                               fallback=lambda: self._pattern_fixes(scan_results, code_files, severity_filter))
-        return result
+            content = self._format_fix_request(scan_results, code_files, severity_filter)
+            result = self._call_ai(SYSTEM_FIX_GENERATOR, content, "generate_fixes",
+                                   fallback=lambda: self._pattern_fixes(scan_results, code_files, severity_filter))
+            s.set_attribute("fixes_generated", len(result.get("fixes", [])))
+            return result
 
     def _format_fix_request(self, scan_results: Dict, code_files: Dict,
                             severity_filter: str = None) -> str:

{thothctl-0.14.2 → thothctl-0.14.4}/src/thothctl/services/ai_review/decision_engine.py

@@ -6,6 +6,7 @@ from typing import Dict, Any, List, Optional
 
 from .config.decision_rules import DecisionRules, BLOCKING_PATTERNS
 from .safety.safety_guard import SafetyGuard
+from .tracing import span
 
 logger = logging.getLogger(__name__)
 
@@ -40,59 +41,65 @@ class DecisionEngine:
                  repository: str = "", pr_id: str = "",
                  pr_context: Optional[Dict] = None) -> DecisionResult:
         """Evaluate analysis results and return a decision."""
-        summary = analysis.get("summary", {})
-        risk_score = float(analysis.get("risk_score", 50))
-        findings = analysis.get("findings", [])
-        recommendations = analysis.get("recommendations", [])
-
-        critical = summary.get("critical", 0)
-        high = summary.get("high", 0)
-        medium = summary.get("medium", 0)
-        low = summary.get("low", 0)
-
-        findings_summary = {"critical": critical, "high": high, "medium": medium, "low": low}
-
-        # Check for blocking patterns in findings
-        has_blocking = self._has_blocking_patterns(findings)
-
-        # Determine raw decision
-        decision, confidence, reason = self._compute_decision(
-            risk_score, critical, high, medium, has_blocking, findings,
-        )
-
-        # Safety gate
-        if decision != Decision.COMMENT and repository:
-            allowed, safety_reason = self.safety.can_take_action(
-                decision.value, confidence, repository, pr_context,
+        with span("decision_engine.evaluate", {"repository": repository, "pr_id": pr_id}) as s:
+            summary = analysis.get("summary", {})
+            risk_score = float(analysis.get("risk_score", 50))
+            findings = analysis.get("findings", [])
+            recommendations = analysis.get("recommendations", [])
+
+            critical = summary.get("critical", 0)
+            high = summary.get("high", 0)
+            medium = summary.get("medium", 0)
+            low = summary.get("low", 0)
+
+            findings_summary = {"critical": critical, "high": high, "medium": medium, "low": low}
+
+            has_blocking = self._has_blocking_patterns(findings)
+
+            decision, confidence, reason = self._compute_decision(
+                risk_score, critical, high, medium, has_blocking, findings,
             )
-            if not allowed:
-                return DecisionResult(
-                    decision=Decision.COMMENT,
-                    confidence=confidence,
-                    reason=reason,
-                    risk_score=risk_score,
-                    findings_summary=findings_summary,
-                    recommendations=recommendations,
-                    blocked_by_safety=True,
-                    safety_reason=safety_reason,
+
+            if decision != Decision.COMMENT and repository:
+                allowed, safety_reason = self.safety.can_take_action(
+                    decision.value, confidence, repository, pr_context,
+                )
+                if not allowed:
+                    s.set_attribute("decision", "comment")
+                    s.set_attribute("blocked_by_safety", True)
+                    s.set_attribute("safety_reason", safety_reason)
+                    s.set_attribute("risk_score", risk_score)
+                    return DecisionResult(
+                        decision=Decision.COMMENT,
+                        confidence=confidence,
+                        reason=reason,
+                        risk_score=risk_score,
+                        findings_summary=findings_summary,
+                        recommendations=recommendations,
+                        blocked_by_safety=True,
+                        safety_reason=safety_reason,
+                    )
+
+            if decision != Decision.COMMENT and repository:
+                self.safety.record_action(
+                    action=decision.value, repository=repository,
+                    pr_id=pr_id, confidence=confidence, reason=reason,
                 )
 
-        # Record if taking action
-        if decision != Decision.COMMENT and repository:
-            self.safety.record_action(
-                action=decision.value, repository=repository,
-                pr_id=pr_id, confidence=confidence, reason=reason,
+            s.set_attribute("decision", decision.value)
+            s.set_attribute("confidence", confidence)
+            s.set_attribute("risk_score", risk_score)
+            s.set_attribute("has_blocking_patterns", has_blocking)
+
+            return DecisionResult(
+                decision=decision,
+                confidence=confidence,
+                reason=reason,
+                risk_score=risk_score,
+                findings_summary=findings_summary,
+                recommendations=recommendations,
             )
 
-        return DecisionResult(
-            decision=decision,
-            confidence=confidence,
-            reason=reason,
-            risk_score=risk_score,
-            findings_summary=findings_summary,
-            recommendations=recommendations,
-        )
-
     def _compute_decision(self, risk_score: float, critical: int, high: int,
                           medium: int, has_blocking: bool,
                           findings: List[Dict]) -> tuple:

{thothctl-0.14.2 → thothctl-0.14.4}/src/thothctl/services/ai_review/main.py

@@ -27,6 +27,8 @@ from typing import Any, Dict
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
 
+from .tracing import span
+
 logger = logging.getLogger(__name__)
 
 app = FastAPI(title="ThothCTL AgentCore Agent", version="0.13.2")
@@ -62,15 +64,20 @@ async def invocations(request: Request):
     if not mode:
         mode = _detect_mode(prompt)
 
-    try:
-        result = _dispatch(
-            mode=mode, directory=directory, provider=provider, model=model,
-            roles=roles, repository=repository, run_id=run_id, prompt=prompt,
-        )
-        return JSONResponse(content={"result": result})
-    except Exception as e:
-        logger.exception("Invocation failed")
-        return JSONResponse(status_code=500, content={"error": str(e)})
+    with span("invocations", {"mode": mode, "directory": directory,
+                              "provider": provider, "repository": repository,
+                              "run_id": run_id}) as s:
+        try:
+            result = _dispatch(
+                mode=mode, directory=directory, provider=provider, model=model,
+                roles=roles, repository=repository, run_id=run_id, prompt=prompt,
+            )
+            s.set_attribute("result.status", "ok")
+            return JSONResponse(content={"result": result})
+        except Exception as e:
+            logger.exception("Invocation failed")
+            s.set_attribute("result.status", "error")
+            return JSONResponse(status_code=500, content={"error": str(e)})
 
 
 # ── Existing REST endpoints (kept for direct API use) ───────────────

{thothctl-0.14.2 → thothctl-0.14.4}/src/thothctl/services/ai_review/memory.py

@@ -18,6 +18,8 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+from .tracing import span
+
 logger = logging.getLogger(__name__)
 
 LOCAL_SESSIONS_DIR = ".thothctl/ai_sessions"
@@ -101,18 +103,21 @@ class AgentMemory:
 
     def save_analysis(self, repo: str, analysis: Dict[str, Any], run_id: str = "") -> None:
         key = self._scoped_key(repo, "analysis", run_id)
-        data = {
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "repo": repo,
-            "run_id": run_id,
-            "analysis": analysis,
-        }
-        self._backend.write(key, data)
+        with span("memory.save_analysis", {"repo": repo, "run_id": run_id, "backend": self.mode}):
+            data = {
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "repo": repo,
+                "run_id": run_id,
+                "analysis": analysis,
+            }
+            self._backend.write(key, data)
 
     def load_analysis(self, repo: str, run_id: str = "") -> Optional[Dict[str, Any]]:
         key = self._scoped_key(repo, "analysis", run_id)
-        data = self._backend.read(key)
-        return data.get("analysis") if data else None
+        with span("memory.load_analysis", {"repo": repo, "run_id": run_id, "backend": self.mode}) as s:
+            data = self._backend.read(key)
+            s.set_attribute("cache_hit", data is not None)
+            return data.get("analysis") if data else None
 
     # -- Session history (per session ID) --
 

{thothctl-0.14.2 → thothctl-0.14.4}/src/thothctl/services/ai_review/orchestrator.py

@@ -25,6 +25,7 @@ from .config.ai_settings import AISettings, ProviderConfig
 from .analyzers.context_builder import ContextBuilder, IaCContext
 from .utils.cost_tracker import CostTracker
 from .memory import AgentMemory, MemoryConfig
+from .tracing import span
 
 logger = logging.getLogger(__name__)
 
@@ -123,39 +124,48 @@ class AgentOrchestrator:
         if roles is None:
             roles = [AgentRole.SECURITY, AgentRole.ARCHITECTURE]
 
-        # Build shared context once
-        logger.info(f"Building context for {directory}")
-        ctx = self.context_builder.build_context(directory)
-
-        # Enrich context with previous analysis from memory
-        if repository:
-            previous = self.memory.load_analysis(repository, run_id=run_id)
-            if previous:
-                ctx.errors.append(f"Previous analysis loaded from memory ({repository})")
-                self._inject_previous_context(ctx, previous)
-
-        # Create tasks for requested roles
-        tasks = self._create_tasks(ctx, roles)
-
-        if not self.cost_tracker.check_budget():
-            logger.warning("Budget exceeded — running offline agents only")
-            return self._offline_result(ctx, roles)
-
-        # Execute agents (parallel where possible)
-        result = OrchestratorResult()
-        self._execute_tasks(tasks, result)
-
-        # If decision was requested, run it last with merged context
-        if AgentRole.DECISION in roles:
-            self._run_decision(result, ctx)
-
-        result.cost = self.cost_tracker.get_cost_report("daily")
-
-        # Persist results to memory
-        if repository:
-            self._save_to_memory(repository, result, run_id=run_id)
-
-        return result
+        with span("orchestrator.run_agents", {
+            "directory": directory,
+            "roles": [r.value for r in roles],
+            "repository": repository,
+            "run_id": run_id,
+        }) as s:
+            # Build shared context once
+            logger.info(f"Building context for {directory}")
+            ctx = self.context_builder.build_context(directory)
+
+            # Enrich context with previous analysis from memory
+            if repository:
+                previous = self.memory.load_analysis(repository, run_id=run_id)
+                if previous:
+                    ctx.errors.append(f"Previous analysis loaded from memory ({repository})")
+                    self._inject_previous_context(ctx, previous)
+
+            # Create tasks for requested roles
+            tasks = self._create_tasks(ctx, roles)
+
+            if not self.cost_tracker.check_budget():
+                logger.warning("Budget exceeded — running offline agents only")
+                s.set_attribute("budget_exceeded", True)
+                return self._offline_result(ctx, roles)
+
+            # Execute agents (parallel where possible)
+            result = OrchestratorResult()
+            self._execute_tasks(tasks, result)
+
+            # If decision was requested, run it last with merged context
+            if AgentRole.DECISION in roles:
+                self._run_decision(result, ctx)
+
+            result.cost = self.cost_tracker.get_cost_report("daily")
+
+            # Persist results to memory
+            if repository:
+                self._save_to_memory(repository, result, run_id=run_id)
+
+            s.set_attribute("agents_executed", len(tasks))
+            s.set_attribute("errors", len(result.errors))
+            return result
 
     def run_single_agent(self, directory: str, role: AgentRole) -> Dict[str, Any]:
         """Run a single specialized agent."""
@@ -212,22 +222,23 @@ class AgentOrchestrator:
         if not tasks:
             return
 
-        if self.max_parallel <= 1 or len(tasks) == 1:
-            for task in tasks:
-                self._run_task(task, result)
-        else:
-            with ThreadPoolExecutor(max_workers=min(self.max_parallel, len(tasks))) as pool:
-                futures = {pool.submit(self._call_ai, task): task for task in tasks}
-                for future in as_completed(futures):
-                    task = futures[future]
-                    try:
-                        ai_result = future.result()
-                        if task.post_process:
-                            ai_result = task.post_process(ai_result)
-                        setattr(result, task.role.value, ai_result)
-                    except Exception as e:
-                        logger.error(f"Agent {task.role.value} failed: {e}")
-                        result.errors.append(f"{task.role.value}: {e}")
+        with span("orchestrator.execute_tasks", {"task_count": len(tasks), "parallel": self.max_parallel > 1}):
+            if self.max_parallel <= 1 or len(tasks) == 1:
+                for task in tasks:
+                    self._run_task(task, result)
+            else:
+                with ThreadPoolExecutor(max_workers=min(self.max_parallel, len(tasks))) as pool:
+                    futures = {pool.submit(self._call_ai, task): task for task in tasks}
+                    for future in as_completed(futures):
+                        task = futures[future]
+                        try:
+                            ai_result = future.result()
+                            if task.post_process:
+                                ai_result = task.post_process(ai_result)
+                            setattr(result, task.role.value, ai_result)
+                        except Exception as e:
+                            logger.error(f"Agent {task.role.value} failed: {e}")
+                            result.errors.append(f"{task.role.value}: {e}")
 
     def _run_task(self, task: AgentTask, result: OrchestratorResult):
         """Run a single task synchronously."""
@@ -242,16 +253,25 @@ class AgentOrchestrator:
 
     def _call_ai(self, task: AgentTask) -> Dict[str, Any]:
         """Send task to AI provider and track cost."""
-        ai_result = self._provider.analyze(task.system_prompt, task.context)
-        usage = ai_result.pop("_usage", {})
-        self.cost_tracker.record_usage(
-            provider=self._provider.name,
-            model=self._provider.model,
-            input_tokens=usage.get("input_tokens", 0),
-            output_tokens=usage.get("output_tokens", 0),
-            operation=f"agent_{task.role.value}",
-        )
-        return ai_result
+        with span("orchestrator.call_ai", {
+            "agent.role": task.role.value,
+            "provider": self._provider.name,
+            "model": self._provider.model,
+        }) as s:
+            ai_result = self._provider.analyze(task.system_prompt, task.context)
+            usage = ai_result.pop("_usage", {})
+            input_tokens = usage.get("input_tokens", 0)
+            output_tokens = usage.get("output_tokens", 0)
+            s.set_attribute("tokens.input", input_tokens)
+            s.set_attribute("tokens.output", output_tokens)
+            self.cost_tracker.record_usage(
+                provider=self._provider.name,
+                model=self._provider.model,
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                operation=f"agent_{task.role.value}",
+            )
+            return ai_result
 
     def _run_decision(self, result: OrchestratorResult, ctx: IaCContext):
         """Run decision agent using merged results from other agents."""

{thothctl-0.14.2 → thothctl-0.14.4}/src/thothctl/services/ai_review/providers/azure_provider.py

@@ -4,6 +4,7 @@ import logging
 from typing import Dict, Any
 
 from ..config.ai_settings import ProviderConfig
+from ..tracing import span
 
 logger = logging.getLogger(__name__)
 
@@ -35,23 +36,25 @@ class AzureOpenAIProvider:
 
     def analyze(self, system_prompt: str, user_content: str) -> Dict[str, Any]:
         """Send analysis request to Azure OpenAI and return parsed JSON response."""
-        response = self.client.chat.completions.create(
-            model=self.model,
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_content},
-            ],
-            max_tokens=self.max_tokens,
-            temperature=self.temperature,
-            response_format={"type": "json_object"},
-        )
-        usage = response.usage
-        result = json.loads(response.choices[0].message.content)
-        result["_usage"] = {
-            "input_tokens": usage.prompt_tokens,
-            "output_tokens": usage.completion_tokens,
-        }
-        return result
+        with span("provider.azure.analyze", {"model": self.model}) as s:
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_content},
+                ],
+                max_tokens=self.max_tokens,
+                temperature=self.temperature,
+                response_format={"type": "json_object"},
+            )
+            usage = response.usage
+            result = json.loads(response.choices[0].message.content)
+            input_tokens = usage.prompt_tokens
+            output_tokens = usage.completion_tokens
+            result["_usage"] = {"input_tokens": input_tokens, "output_tokens": output_tokens}
+            s.set_attribute("tokens.input", input_tokens)
+            s.set_attribute("tokens.output", output_tokens)
+            return result
 
     @property
     def name(self) -> str: