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.
@@ -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