lanternfish 0.3.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- lanternfish/__init__.py +61 -0
- lanternfish/configuration.py +81 -0
- lanternfish/context.py +67 -0
- lanternfish/decorators.py +222 -0
- lanternfish/deployments.py +69 -0
- lanternfish/errors.py +9 -0
- lanternfish/exporters.py +34 -0
- lanternfish/instrument.py +181 -0
- lanternfish/integrations/__init__.py +61 -0
- lanternfish/integrations/anthropic.py +20 -0
- lanternfish/integrations/autogen.py +75 -0
- lanternfish/integrations/crewai.py +17 -0
- lanternfish/integrations/gemini.py +24 -0
- lanternfish/integrations/groq.py +21 -0
- lanternfish/integrations/haystack.py +65 -0
- lanternfish/integrations/http.py +129 -0
- lanternfish/integrations/instrumentor.py +24 -0
- lanternfish/integrations/langchain.py +21 -0
- lanternfish/integrations/llamaindex.py +21 -0
- lanternfish/integrations/mcp.py +208 -0
- lanternfish/integrations/ollama.py +73 -0
- lanternfish/integrations/openai.py +17 -0
- lanternfish/integrations/openai_agents.py +78 -0
- lanternfish/integrations/pydantic_ai.py +66 -0
- lanternfish/integrations/redis.py +296 -0
- lanternfish/integrations/sql.py +300 -0
- lanternfish/json_exporter.py +170 -0
- lanternfish/providers.py +14 -0
- lanternfish/py.typed +0 -0
- lanternfish/semantic.py +794 -0
- lanternfish/span_processor.py +69 -0
- lanternfish-0.3.0.dist-info/METADATA +137 -0
- lanternfish-0.3.0.dist-info/RECORD +35 -0
- lanternfish-0.3.0.dist-info/WHEEL +5 -0
- lanternfish-0.3.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,208 @@
|
|
|
1
|
+
# mcp.py
|
|
2
|
+
# Gorev: MCP (Model Context Protocol) Client ve Server cagrilarini OpenTelemetry ile izlemek
|
|
3
|
+
# Yapmaz: TracerProvider veya exporter olusturmaz
|
|
4
|
+
#
|
|
5
|
+
# Gercek API (mcp >= 1.0):
|
|
6
|
+
# MCP CLIENT:
|
|
7
|
+
# ClientSession.call_tool(name, arguments=None, ...) -> CallToolResult
|
|
8
|
+
# ClientSession.initialize() -> InitializeResult (result.serverInfo.name = server adi)
|
|
9
|
+
# CallToolResult.content: list[TextContent | ...], CallToolResult.isError: bool
|
|
10
|
+
#
|
|
11
|
+
# MCP SERVER (FastMCP):
|
|
12
|
+
# FastMCP(name, ...) -> server instance, server.name = server adi
|
|
13
|
+
# FastMCP.call_tool(name, arguments) -> her tool cagrisinin merkezi noktasi
|
|
14
|
+
# @server.tool() / server.add_tool(fn) -> tool register eder
|
|
15
|
+
#
|
|
16
|
+
# Strateji:
|
|
17
|
+
# Client: initialize() + call_tool() patch
|
|
18
|
+
# - initialize(): server adi + versiyonu _server_info dict'e kaydeder
|
|
19
|
+
# - call_tool(): input payload (tam JSON), output payload, error details, caller bilgisi
|
|
20
|
+
# Server: FastMCP.call_tool() patch (tek merkezi nokta, tum @tool dekorator cagrisi buradan gecer)
|
|
21
|
+
|
|
22
|
+
import functools
|
|
23
|
+
import json
|
|
24
|
+
import traceback as _traceback
|
|
25
|
+
from typing import Any
|
|
26
|
+
|
|
27
|
+
from opentelemetry import trace as otel_trace
|
|
28
|
+
from opentelemetry.sdk.trace import TracerProvider
|
|
29
|
+
from opentelemetry.trace import StatusCode
|
|
30
|
+
|
|
31
|
+
|
|
32
|
+
def instrument_mcp(tracer_provider: TracerProvider) -> None:
|
|
33
|
+
"""MCP ClientSession.call_tool() cagrilarini verilen tracer provider ile izler.
|
|
34
|
+
|
|
35
|
+
Her tool cagrisi icin span olusturur: tool adi, server adi, argumanlar,
|
|
36
|
+
sonuc ozeti ve hata durumu kaydedilir. initialize() patch'i sayesinde
|
|
37
|
+
server adi otomatik yakalanir.
|
|
38
|
+
|
|
39
|
+
Args:
|
|
40
|
+
tracer_provider: Span'lerin gonderilecegi TracerProvider.
|
|
41
|
+
"""
|
|
42
|
+
# Kütüphane yüklü değilse ImportError instrument()'a çıkar; o entegrasyon atlanır.
|
|
43
|
+
from mcp import ClientSession
|
|
44
|
+
|
|
45
|
+
tracer = otel_trace.get_tracer("lanternfish.mcp", tracer_provider=tracer_provider)
|
|
46
|
+
|
|
47
|
+
# ── initialize() patch: server adi + versiyonunu sakla ───────────────────
|
|
48
|
+
original_initialize = ClientSession.initialize
|
|
49
|
+
|
|
50
|
+
@functools.wraps(original_initialize)
|
|
51
|
+
async def traced_initialize(self: Any) -> Any:
|
|
52
|
+
result = await original_initialize(self)
|
|
53
|
+
server_info = getattr(result, "serverInfo", None)
|
|
54
|
+
if server_info is not None:
|
|
55
|
+
self._server_info = {
|
|
56
|
+
"name": getattr(server_info, "name", "unknown"),
|
|
57
|
+
"version": getattr(server_info, "version", "unknown"),
|
|
58
|
+
}
|
|
59
|
+
return result
|
|
60
|
+
|
|
61
|
+
ClientSession.initialize = traced_initialize
|
|
62
|
+
|
|
63
|
+
# ── call_tool() patch: detayli izleme ────────────────────────────────────
|
|
64
|
+
original_call_tool = ClientSession.call_tool
|
|
65
|
+
|
|
66
|
+
@functools.wraps(original_call_tool)
|
|
67
|
+
async def traced_call_tool(
|
|
68
|
+
self: Any,
|
|
69
|
+
name: str,
|
|
70
|
+
arguments: dict | None = None,
|
|
71
|
+
**kwargs: Any,
|
|
72
|
+
) -> Any:
|
|
73
|
+
with tracer.start_as_current_span(f"mcp.call_tool {name}") as span:
|
|
74
|
+
span.set_attribute("gen_ai.system", "mcp")
|
|
75
|
+
span.set_attribute("mcp.tool_name", name)
|
|
76
|
+
|
|
77
|
+
# Server bilgisi (initialize() sonrasi mevcut olur)
|
|
78
|
+
server_info = getattr(self, "_server_info", None)
|
|
79
|
+
if server_info:
|
|
80
|
+
span.set_attribute("mcp.server_name", server_info.get("name", "unknown"))
|
|
81
|
+
span.set_attribute("mcp.server_version", server_info.get("version", "unknown"))
|
|
82
|
+
|
|
83
|
+
# Caller bilgisi (hangi span bu tool'u cagridi)
|
|
84
|
+
current_span = otel_trace.get_current_span()
|
|
85
|
+
parent = getattr(current_span, "parent", None)
|
|
86
|
+
if parent is not None:
|
|
87
|
+
parent_name = getattr(parent, "name", None)
|
|
88
|
+
if parent_name:
|
|
89
|
+
span.set_attribute("mcp.caller.span_name", parent_name)
|
|
90
|
+
|
|
91
|
+
# Input payload (tam JSON)
|
|
92
|
+
if arguments:
|
|
93
|
+
try:
|
|
94
|
+
input_json = json.dumps(arguments, indent=2, ensure_ascii=False)
|
|
95
|
+
except Exception:
|
|
96
|
+
input_json = str(arguments)
|
|
97
|
+
span.set_attribute("mcp.input.payload", input_json)
|
|
98
|
+
span.set_attribute("mcp.input.argument_count", len(arguments))
|
|
99
|
+
|
|
100
|
+
try:
|
|
101
|
+
result = await original_call_tool(self, name, arguments, **kwargs)
|
|
102
|
+
|
|
103
|
+
# isError flag'i
|
|
104
|
+
is_error = getattr(result, "isError", False)
|
|
105
|
+
if is_error:
|
|
106
|
+
span.set_status(StatusCode.ERROR, f"MCP tool '{name}' returned isError=True")
|
|
107
|
+
span.set_attribute("mcp.is_error", True)
|
|
108
|
+
else:
|
|
109
|
+
span.set_status(StatusCode.OK)
|
|
110
|
+
|
|
111
|
+
# Output payload (Pydantic model -> dict -> JSON)
|
|
112
|
+
try:
|
|
113
|
+
if hasattr(result, "model_dump"):
|
|
114
|
+
result_dict = result.model_dump()
|
|
115
|
+
elif hasattr(result, "dict"):
|
|
116
|
+
result_dict = result.dict()
|
|
117
|
+
else:
|
|
118
|
+
result_dict = str(result)
|
|
119
|
+
output_json = json.dumps(result_dict, ensure_ascii=False, default=str)
|
|
120
|
+
span.set_attribute("mcp.output.payload", output_json)
|
|
121
|
+
span.set_attribute("mcp.output.size_bytes", len(output_json.encode("utf-8")))
|
|
122
|
+
except Exception:
|
|
123
|
+
span.set_attribute("mcp.output.payload", str(result))
|
|
124
|
+
|
|
125
|
+
return result
|
|
126
|
+
|
|
127
|
+
except Exception as exc:
|
|
128
|
+
span.set_status(StatusCode.ERROR, str(exc))
|
|
129
|
+
span.set_attribute("mcp.error.type", type(exc).__name__)
|
|
130
|
+
span.set_attribute("mcp.error.message", str(exc))
|
|
131
|
+
tb = _traceback.format_exc()
|
|
132
|
+
if len(tb) > 2000:
|
|
133
|
+
tb = tb[:2000] + "... [truncated]"
|
|
134
|
+
span.set_attribute("mcp.error.traceback", tb)
|
|
135
|
+
span.record_exception(exc)
|
|
136
|
+
raise
|
|
137
|
+
|
|
138
|
+
ClientSession.call_tool = traced_call_tool
|
|
139
|
+
|
|
140
|
+
|
|
141
|
+
def instrument_mcp_server(tracer_provider: TracerProvider) -> None:
|
|
142
|
+
"""MCP FastMCP Server tool cagrilarini verilen tracer provider ile izler.
|
|
143
|
+
|
|
144
|
+
FastMCP.call_tool() merkezi patch noktasidir: @server.tool() ile register
|
|
145
|
+
edilen tum fonksiyonlarin cagrisi buradan gecer. Server adi self.name'den alinir.
|
|
146
|
+
Her tool cagrisi icin ayri span olusturulur: tool adi, server adi, argumanlar
|
|
147
|
+
ve sonuc ozeti kaydedilir.
|
|
148
|
+
|
|
149
|
+
Not: Dusuk seviyeli mcp.server.Server sinifi tool decorator sunmaz;
|
|
150
|
+
FastMCP kullanici tarafli MCP server yazmak icin tercih edilen API'dir.
|
|
151
|
+
|
|
152
|
+
Args:
|
|
153
|
+
tracer_provider: Span'lerin gonderilecegi TracerProvider.
|
|
154
|
+
"""
|
|
155
|
+
# Kütüphane yüklü değilse ImportError instrument()'a çıkar; o entegrasyon atlanır.
|
|
156
|
+
from mcp.server.fastmcp import FastMCP
|
|
157
|
+
|
|
158
|
+
tracer = otel_trace.get_tracer("lanternfish.mcp.server", tracer_provider=tracer_provider)
|
|
159
|
+
original_call_tool = FastMCP.call_tool
|
|
160
|
+
|
|
161
|
+
@functools.wraps(original_call_tool)
|
|
162
|
+
async def traced_server_call_tool(
|
|
163
|
+
self: Any,
|
|
164
|
+
name: str,
|
|
165
|
+
arguments: dict,
|
|
166
|
+
**kwargs: Any,
|
|
167
|
+
) -> Any:
|
|
168
|
+
server_name = getattr(self, "name", "unknown")
|
|
169
|
+
with tracer.start_as_current_span(f"mcp.server.tool {name}") as span:
|
|
170
|
+
span.set_attribute("gen_ai.system", "mcp")
|
|
171
|
+
span.set_attribute("mcp.server_name", server_name)
|
|
172
|
+
span.set_attribute("mcp.tool_name", name)
|
|
173
|
+
|
|
174
|
+
# Argumanlar JSON, 500 karakterde kisalt
|
|
175
|
+
if arguments:
|
|
176
|
+
try:
|
|
177
|
+
args_str = json.dumps(arguments, ensure_ascii=False)
|
|
178
|
+
except Exception:
|
|
179
|
+
args_str = str(arguments)
|
|
180
|
+
if len(args_str) > 500:
|
|
181
|
+
args_str = args_str[:500] + "... [truncated]"
|
|
182
|
+
span.set_attribute("mcp.arguments", args_str)
|
|
183
|
+
|
|
184
|
+
try:
|
|
185
|
+
result = await original_call_tool(self, name, arguments, **kwargs)
|
|
186
|
+
|
|
187
|
+
# Sonuc ozeti (500 karakterde kisalt)
|
|
188
|
+
if result is not None:
|
|
189
|
+
try:
|
|
190
|
+
result_str = json.dumps(
|
|
191
|
+
result if isinstance(result, (dict, list)) else str(result),
|
|
192
|
+
ensure_ascii=False,
|
|
193
|
+
)
|
|
194
|
+
except Exception:
|
|
195
|
+
result_str = str(result)
|
|
196
|
+
if len(result_str) > 500:
|
|
197
|
+
result_str = result_str[:500] + "... [truncated]"
|
|
198
|
+
span.set_attribute("mcp.result", result_str)
|
|
199
|
+
|
|
200
|
+
span.set_status(StatusCode.OK)
|
|
201
|
+
return result
|
|
202
|
+
|
|
203
|
+
except Exception as exc:
|
|
204
|
+
span.set_status(StatusCode.ERROR, str(exc))
|
|
205
|
+
span.record_exception(exc)
|
|
206
|
+
raise
|
|
207
|
+
|
|
208
|
+
FastMCP.call_tool = traced_server_call_tool
|
|
@@ -0,0 +1,73 @@
|
|
|
1
|
+
# ollama.py
|
|
2
|
+
# Gorev: Ollama (local LLM) cagrilarini OpenTelemetry ile enstrumante etmek
|
|
3
|
+
# Yapmaz: TracerProvider veya exporter olusturmaz
|
|
4
|
+
#
|
|
5
|
+
# Not: Ollama icin resmi OTel paketi yok. ollama.Client.chat ve
|
|
6
|
+
# ollama.Client.generate metodlari monkey-patch ile sariliyor.
|
|
7
|
+
|
|
8
|
+
import functools
|
|
9
|
+
from typing import Any
|
|
10
|
+
|
|
11
|
+
from opentelemetry import trace
|
|
12
|
+
from opentelemetry.sdk.trace import TracerProvider
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
def instrument_ollama(tracer_provider: TracerProvider) -> None:
|
|
16
|
+
"""Ollama SDK cagrilarini verilen tracer provider ile izler.
|
|
17
|
+
|
|
18
|
+
ollama.Client.chat() ve ollama.Client.generate() cagrilarini yakalar;
|
|
19
|
+
model adi, token sayilari (eval_count / prompt_eval_count) ve latency
|
|
20
|
+
gen_ai.* attribute'lari olarak kaydedilir.
|
|
21
|
+
|
|
22
|
+
Args:
|
|
23
|
+
tracer_provider: Span'lerin gonderilecegi TracerProvider.
|
|
24
|
+
"""
|
|
25
|
+
import ollama as _ollama
|
|
26
|
+
|
|
27
|
+
tracer = trace.get_tracer("lanternfish.ollama", tracer_provider=tracer_provider)
|
|
28
|
+
|
|
29
|
+
_patch_chat(tracer, _ollama)
|
|
30
|
+
_patch_generate(tracer, _ollama)
|
|
31
|
+
|
|
32
|
+
|
|
33
|
+
def _patch_chat(tracer: trace.Tracer, ollama_module: Any) -> None:
|
|
34
|
+
original = ollama_module.Client.chat
|
|
35
|
+
|
|
36
|
+
@functools.wraps(original)
|
|
37
|
+
def traced_chat(self: Any, model: str = "", messages: Any = None, **kwargs: Any) -> Any:
|
|
38
|
+
with tracer.start_as_current_span(f"ollama.chat") as span:
|
|
39
|
+
span.set_attribute("gen_ai.system", "ollama")
|
|
40
|
+
span.set_attribute("gen_ai.request.model", model)
|
|
41
|
+
|
|
42
|
+
result = original(self, model, messages, **kwargs)
|
|
43
|
+
|
|
44
|
+
# ChatResponse token alanlari: prompt_eval_count, eval_count
|
|
45
|
+
if hasattr(result, "prompt_eval_count") and result.prompt_eval_count:
|
|
46
|
+
span.set_attribute("gen_ai.usage.input_tokens", result.prompt_eval_count)
|
|
47
|
+
if hasattr(result, "eval_count") and result.eval_count:
|
|
48
|
+
span.set_attribute("gen_ai.usage.output_tokens", result.eval_count)
|
|
49
|
+
|
|
50
|
+
return result
|
|
51
|
+
|
|
52
|
+
ollama_module.Client.chat = traced_chat
|
|
53
|
+
|
|
54
|
+
|
|
55
|
+
def _patch_generate(tracer: trace.Tracer, ollama_module: Any) -> None:
|
|
56
|
+
original = ollama_module.Client.generate
|
|
57
|
+
|
|
58
|
+
@functools.wraps(original)
|
|
59
|
+
def traced_generate(self: Any, model: str = "", prompt: str = "", **kwargs: Any) -> Any:
|
|
60
|
+
with tracer.start_as_current_span(f"ollama.generate") as span:
|
|
61
|
+
span.set_attribute("gen_ai.system", "ollama")
|
|
62
|
+
span.set_attribute("gen_ai.request.model", model)
|
|
63
|
+
|
|
64
|
+
result = original(self, model, prompt, **kwargs)
|
|
65
|
+
|
|
66
|
+
if hasattr(result, "prompt_eval_count") and result.prompt_eval_count:
|
|
67
|
+
span.set_attribute("gen_ai.usage.input_tokens", result.prompt_eval_count)
|
|
68
|
+
if hasattr(result, "eval_count") and result.eval_count:
|
|
69
|
+
span.set_attribute("gen_ai.usage.output_tokens", result.eval_count)
|
|
70
|
+
|
|
71
|
+
return result
|
|
72
|
+
|
|
73
|
+
ollama_module.Client.generate = traced_generate
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
# openai.py
|
|
2
|
+
# Görev: OpenAI çağrılarını OpenTelemetry ile otomatik enstrümante etmek
|
|
3
|
+
# Yapmaz: TracerProvider veya exporter oluşturmaz
|
|
4
|
+
|
|
5
|
+
from opentelemetry.instrumentation.openai import OpenAIInstrumentor
|
|
6
|
+
from opentelemetry.sdk.trace import TracerProvider
|
|
7
|
+
|
|
8
|
+
from lanternfish.integrations.instrumentor import enable_instrumentor
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
def instrument_openai(tracer_provider: TracerProvider) -> None:
|
|
12
|
+
"""OpenAI SDK çağrılarını verilen tracer provider ile izler.
|
|
13
|
+
|
|
14
|
+
Args:
|
|
15
|
+
tracer_provider: Span'lerin gönderileceği TracerProvider.
|
|
16
|
+
"""
|
|
17
|
+
enable_instrumentor(OpenAIInstrumentor(), tracer_provider)
|
|
@@ -0,0 +1,78 @@
|
|
|
1
|
+
# openai_agents.py
|
|
2
|
+
# Gorev: OpenAI Agents SDK (openai-agents) cagrilarini OpenTelemetry ile enstrumante etmek
|
|
3
|
+
# Yapmaz: TracerProvider veya exporter olusturmaz
|
|
4
|
+
#
|
|
5
|
+
# Gercek API:
|
|
6
|
+
# Runner.run(starting_agent, input, context, max_turns, ...) <- async
|
|
7
|
+
# Agent.name, Agent.model, Agent.instructions, Agent.get_all_tools()
|
|
8
|
+
# RunResult.final_output
|
|
9
|
+
|
|
10
|
+
import functools
|
|
11
|
+
from typing import Any
|
|
12
|
+
|
|
13
|
+
from opentelemetry import trace
|
|
14
|
+
from opentelemetry.sdk.trace import TracerProvider
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
def instrument_openai_agents(tracer_provider: TracerProvider) -> None:
|
|
18
|
+
"""OpenAI Agents SDK Runner.run() cagrilarini verilen tracer provider ile izler.
|
|
19
|
+
|
|
20
|
+
Runner.run() sararak; agent adi, modeli, tool sayisi, output uzunlugu
|
|
21
|
+
ve latency agent.* attribute'lari olarak kaydedilir.
|
|
22
|
+
SDK'nin kendi OpenAI tracing'i devre disi birakilir; OTel span'leri kullanilir.
|
|
23
|
+
|
|
24
|
+
Args:
|
|
25
|
+
tracer_provider: Span'lerin gonderilecegi TracerProvider.
|
|
26
|
+
"""
|
|
27
|
+
# Kütüphane yüklü değilse ImportError instrument()'a çıkar; o entegrasyon atlanır.
|
|
28
|
+
from agents import Runner, set_tracing_disabled
|
|
29
|
+
|
|
30
|
+
# SDK'nin kendi OpenAI platform tracing'ini kapat
|
|
31
|
+
set_tracing_disabled(True)
|
|
32
|
+
|
|
33
|
+
# OpenAI Agents SDK standard OpenTelemetry tracer
|
|
34
|
+
tracer = trace.get_tracer("lanternfish.openai_agents", tracer_provider=tracer_provider)
|
|
35
|
+
original_run = Runner.run
|
|
36
|
+
|
|
37
|
+
@functools.wraps(original_run)
|
|
38
|
+
async def traced_run(
|
|
39
|
+
starting_agent: Any,
|
|
40
|
+
input: Any,
|
|
41
|
+
**kwargs: Any,
|
|
42
|
+
) -> Any:
|
|
43
|
+
agent_name = getattr(starting_agent, "name", "unknown")
|
|
44
|
+
model_raw = getattr(starting_agent, "model", None)
|
|
45
|
+
agent_model = (
|
|
46
|
+
model_raw if isinstance(model_raw, str)
|
|
47
|
+
else (
|
|
48
|
+
getattr(model_raw, "model", None)
|
|
49
|
+
or getattr(model_raw, "model_name", None)
|
|
50
|
+
or type(model_raw).__name__
|
|
51
|
+
) if model_raw is not None else "unknown"
|
|
52
|
+
)
|
|
53
|
+
|
|
54
|
+
with tracer.start_as_current_span("agent.run") as span:
|
|
55
|
+
span.set_attribute("gen_ai.system", "openai_agents")
|
|
56
|
+
span.set_attribute("agent.name", str(agent_name))
|
|
57
|
+
span.set_attribute("gen_ai.request.model", str(agent_model))
|
|
58
|
+
|
|
59
|
+
instructions = getattr(starting_agent, "instructions", None)
|
|
60
|
+
if isinstance(instructions, str):
|
|
61
|
+
span.set_attribute("agent.instructions_preview", instructions[:120])
|
|
62
|
+
|
|
63
|
+
try:
|
|
64
|
+
all_tools = starting_agent.get_all_tools()
|
|
65
|
+
if all_tools:
|
|
66
|
+
span.set_attribute("agent.tool_count", len(all_tools))
|
|
67
|
+
except Exception:
|
|
68
|
+
pass
|
|
69
|
+
|
|
70
|
+
result = await original_run(starting_agent, input, **kwargs)
|
|
71
|
+
|
|
72
|
+
final_output = getattr(result, "final_output", None)
|
|
73
|
+
if final_output is not None:
|
|
74
|
+
span.set_attribute("agent.output_length", len(str(final_output)))
|
|
75
|
+
|
|
76
|
+
return result
|
|
77
|
+
|
|
78
|
+
Runner.run = traced_run
|
|
@@ -0,0 +1,66 @@
|
|
|
1
|
+
# pydantic_ai.py
|
|
2
|
+
# Gorev: Pydantic AI Agent.run() cagrilarini OpenTelemetry ile enstrumante etmek
|
|
3
|
+
# Yapmaz: TracerProvider veya exporter olusturmaz
|
|
4
|
+
#
|
|
5
|
+
# Gercek API:
|
|
6
|
+
# Agent._name, Agent._model, Agent._output_type <- private, str ile cevrilir
|
|
7
|
+
# Agent.run(user_prompt, ...) <- async
|
|
8
|
+
# AgentRunResult.usage -> RunUsage(input_tokens, output_tokens, requests, tool_calls)
|
|
9
|
+
# AgentRunResult.response -> output verisi
|
|
10
|
+
|
|
11
|
+
import functools
|
|
12
|
+
from typing import Any
|
|
13
|
+
|
|
14
|
+
from opentelemetry import trace
|
|
15
|
+
from opentelemetry.sdk.trace import TracerProvider
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
def instrument_pydantic_ai(tracer_provider: TracerProvider) -> None:
|
|
19
|
+
"""Pydantic AI Agent.run() cagrilarini verilen tracer provider ile izler.
|
|
20
|
+
|
|
21
|
+
Agent.run() sararak; agent adi, modeli, output type, token sayilari
|
|
22
|
+
ve tool_calls sayisi gen_ai.* + agent.* attribute'lari olarak kaydedilir.
|
|
23
|
+
|
|
24
|
+
Args:
|
|
25
|
+
tracer_provider: Span'lerin gonderilecegi TracerProvider.
|
|
26
|
+
"""
|
|
27
|
+
# Kütüphane yüklü değilse ImportError instrument()'a çıkar; o entegrasyon atlanır.
|
|
28
|
+
from pydantic_ai import Agent
|
|
29
|
+
|
|
30
|
+
tracer = trace.get_tracer("lanternfish.pydantic_ai", tracer_provider=tracer_provider)
|
|
31
|
+
original_run = Agent.run
|
|
32
|
+
|
|
33
|
+
@functools.wraps(original_run)
|
|
34
|
+
async def traced_run(self: Any, user_prompt: Any = None, **kwargs: Any) -> Any:
|
|
35
|
+
agent_name = getattr(self, "_name", None) or "pydantic_agent"
|
|
36
|
+
model_raw = getattr(self, "_model", None)
|
|
37
|
+
model_name = (
|
|
38
|
+
getattr(model_raw, "model_name", None)
|
|
39
|
+
or getattr(model_raw, "model", None)
|
|
40
|
+
or type(model_raw).__name__
|
|
41
|
+
) if model_raw is not None else "unknown"
|
|
42
|
+
|
|
43
|
+
output_type_raw = getattr(self, "_output_type", None)
|
|
44
|
+
output_type_name = (
|
|
45
|
+
getattr(output_type_raw, "__name__", None)
|
|
46
|
+
or str(output_type_raw)
|
|
47
|
+
) if output_type_raw is not None else "str"
|
|
48
|
+
|
|
49
|
+
with tracer.start_as_current_span("pydantic_ai.run") as span:
|
|
50
|
+
span.set_attribute("gen_ai.system", "pydantic_ai")
|
|
51
|
+
span.set_attribute("agent.name", str(agent_name))
|
|
52
|
+
span.set_attribute("gen_ai.request.model", model_name)
|
|
53
|
+
span.set_attribute("agent.output_type", str(output_type_name))
|
|
54
|
+
|
|
55
|
+
result = await original_run(self, user_prompt, **kwargs)
|
|
56
|
+
|
|
57
|
+
usage = getattr(result, "usage", None)
|
|
58
|
+
if usage is not None:
|
|
59
|
+
span.set_attribute("gen_ai.usage.input_tokens", getattr(usage, "input_tokens", 0))
|
|
60
|
+
span.set_attribute("gen_ai.usage.output_tokens", getattr(usage, "output_tokens", 0))
|
|
61
|
+
span.set_attribute("agent.tool_calls", getattr(usage, "tool_calls", 0))
|
|
62
|
+
span.set_attribute("agent.requests", getattr(usage, "requests", 0))
|
|
63
|
+
|
|
64
|
+
return result
|
|
65
|
+
|
|
66
|
+
Agent.run = traced_run
|