openlit 1.34.29__py3-none-any.whl → 1.34.31__py3-none-any.whl

openlit/instrumentation/firecrawl/__init__.py

@@ -6,12 +6,11 @@ import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
-from openlit.instrumentation.firecrawl.firecrawl import (
-    wrap_crawl
-)
+from openlit.instrumentation.firecrawl.firecrawl import wrap_crawl
 
 _instruments = ("firecrawl-py >= 1.6.3",)
 
+
 class FireCrawlInstrumentor(BaseInstrumentor):
     """
     An instrumentor for firecrawl's client library.
@@ -33,15 +32,33 @@ class FireCrawlInstrumentor(BaseInstrumentor):
         wrap_function_wrapper(
             "firecrawl.firecrawl",
             "FirecrawlApp.scrape_url",
-            wrap_crawl("firecrawl.scrape_url", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            wrap_crawl(
+                "firecrawl.scrape_url",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         wrap_function_wrapper(
             "firecrawl.firecrawl",
             "FirecrawlApp.crawl_url",
-            wrap_crawl("firecrawl.crawl_url", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            wrap_crawl(
+                "firecrawl.crawl_url",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
     def _uninstrument(self, **kwargs):

openlit/instrumentation/firecrawl/firecrawl.py

@@ -5,7 +5,11 @@ Module for monitoring FireCrawl calls.
 
 import logging
 from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
+from opentelemetry.sdk.resources import (
+    SERVICE_NAME,
+    TELEMETRY_SDK_NAME,
+    DEPLOYMENT_ENVIRONMENT,
+)
 from openlit.__helpers import (
     handle_exception,
 )
@@ -14,8 +18,18 @@ from openlit.semcov import SemanticConvention
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
 
-def wrap_crawl(gen_ai_endpoint, version, environment, application_name,
-                     tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def wrap_crawl(
+    gen_ai_endpoint,
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for chat completions to collect metrics.
 
@@ -50,28 +64,40 @@ def wrap_crawl(gen_ai_endpoint, version, environment, application_name,
         """
 
         # pylint: disable=line-too-long
-        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            gen_ai_endpoint, kind=SpanKind.CLIENT
+        ) as span:
             response = wrapped(*args, **kwargs)
 
             try:
                 # Set base span attribues
                 span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvention.GEN_AI_SYSTEM,
-                                    SemanticConvention.GEN_AI_SYSTEM_FIRECRAWL)
-                span.set_attribute(SemanticConvention.GEN_AI_OPERATION,
-                                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT)
-                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT,
-                                    gen_ai_endpoint)
-                span.set_attribute(SERVICE_NAME,
-                                    application_name)
-                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
-                                    environment)
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_TYPE,
-                                    SemanticConvention.GEN_AI_AGENT_TYPE_BROWSER)
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_PARAMS,
-                                    str(kwargs.get("params")))
-
-                url = kwargs.get("url") if "url" in kwargs else str(args[0]) if args else None
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_SYSTEM,
+                    SemanticConvention.GEN_AI_SYSTEM_FIRECRAWL,
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_OPERATION,
+                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+                )
+                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT, gen_ai_endpoint)
+                span.set_attribute(SERVICE_NAME, application_name)
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_TYPE,
+                    SemanticConvention.GEN_AI_AGENT_TYPE_BROWSER,
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_PARAMS, str(kwargs.get("params"))
+                )
+
+                url = (
+                    kwargs.get("url")
+                    if "url" in kwargs
+                    else str(args[0])
+                    if args
+                    else None
+                )
                 if url is not None:
                     span.set_attribute(SemanticConvention.GEN_AI_AGENT_BROWSE_URL, url)
 

openlit/instrumentation/google_ai_studio/__init__.py

@@ -6,15 +6,18 @@ from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
 from openlit.instrumentation.google_ai_studio.google_ai_studio import (
-    generate, generate_stream
+    generate,
+    generate_stream,
 )
 
 from openlit.instrumentation.google_ai_studio.async_google_ai_studio import (
-    async_generate, async_generate_stream
+    async_generate,
+    async_generate_stream,
 )
 
 _instruments = ("google-genai >= 1.3.0",)
 
+
 class GoogleAIStudioInstrumentor(BaseInstrumentor):
     """
     An instrumentor for google-genai's client library.
@@ -37,32 +40,64 @@ class GoogleAIStudioInstrumentor(BaseInstrumentor):
         wrap_function_wrapper(
             "google.genai.models",
             "Models.generate_content",
-            generate(version, environment, application_name,
-                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            generate(
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         # sync stream generate
         wrap_function_wrapper(
             "google.genai.models",
             "Models.generate_content_stream",
-            generate_stream(version, environment, application_name,
-                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            generate_stream(
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         # async generate
         wrap_function_wrapper(
             "google.genai.models",
             "AsyncModels.generate_content",
-            async_generate(version, environment, application_name,
-                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            async_generate(
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         # async stream generate
         wrap_function_wrapper(
             "google.genai.models",
             "AsyncModels.generate_content_stream",
-            async_generate_stream(version, environment, application_name,
-                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            async_generate_stream(
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
     def _uninstrument(self, **kwargs):

openlit/instrumentation/google_ai_studio/async_google_ai_studio.py

@@ -4,19 +4,25 @@ Module for monitoring Google AI Studio API calls.
 
 import time
 from opentelemetry.trace import SpanKind
-from openlit.__helpers import (
-    handle_exception,
-    set_server_address_and_port
-)
+from openlit.__helpers import handle_exception, set_server_address_and_port
 from openlit.instrumentation.google_ai_studio.utils import (
     process_chat_response,
     process_chunk,
-    process_streaming_chat_response
+    process_streaming_chat_response,
 )
 from openlit.semcov import SemanticConvention
 
-def async_generate(version, environment, application_name,
-    tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def async_generate(
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for GenAI function call
     """
@@ -26,7 +32,9 @@ def async_generate(version, environment, application_name,
         Wraps the GenAI function call.
         """
 
-        server_address, server_port = set_server_address_and_port(instance, "generativelanguage.googleapis.com", 443)
+        server_address, server_port = set_server_address_and_port(
+            instance, "generativelanguage.googleapis.com", 443
+        )
         request_model = kwargs.get("model", "gemini-2.0-flash")
 
         span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"
@@ -37,22 +45,22 @@ def async_generate(version, environment, application_name,
 
             try:
                 response = process_chat_response(
-                        instance = instance,
-                        response=response,
-                        request_model=request_model,
-                        pricing_info=pricing_info,
-                        server_port=server_port,
-                        server_address=server_address,
-                        environment=environment,
-                        application_name=application_name,
-                        metrics=metrics,
-                        start_time=start_time,
-                        span=span,
-                        args=args,
-                        kwargs=kwargs,
-                        capture_message_content=capture_message_content,
-                        disable_metrics=disable_metrics,
-                        version=version,
+                    instance=instance,
+                    response=response,
+                    request_model=request_model,
+                    pricing_info=pricing_info,
+                    server_port=server_port,
+                    server_address=server_address,
+                    environment=environment,
+                    application_name=application_name,
+                    metrics=metrics,
+                    start_time=start_time,
+                    span=span,
+                    args=args,
+                    kwargs=kwargs,
+                    capture_message_content=capture_message_content,
+                    disable_metrics=disable_metrics,
+                    version=version,
                 )
 
             except Exception as e:
@@ -63,8 +71,17 @@ def async_generate(version, environment, application_name,
 
     return wrapper
 
-def async_generate_stream(version, environment, application_name,
-    tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def async_generate_stream(
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for GenAI function call
     """
@@ -75,23 +92,23 @@ def async_generate_stream(version, environment, application_name,
         """
 
         def __init__(
-                self,
-                wrapped,
-                span,
-                span_name,
-                kwargs,
-                server_address,
-                server_port,
-                **args,
-            ):
+            self,
+            wrapped,
+            span,
+            span_name,
+            kwargs,
+            server_address,
+            server_port,
+            **args,
+        ):
             self.__wrapped__ = wrapped
             self._span = span
             self._span_name = span_name
-            self._llmresponse = ''
-            self._finish_reason = ''
-            self._output_tokens = ''
-            self._input_tokens = ''
-            self._response_model = ''
+            self._llmresponse = ""
+            self._finish_reason = ""
+            self._output_tokens = ""
+            self._input_tokens = ""
+            self._response_model = ""
             self._tools = None
 
             self._args = args
@@ -125,7 +142,9 @@ def async_generate_stream(version, environment, application_name,
                 return chunk
             except StopAsyncIteration:
                 try:
-                    with tracer.start_as_current_span(self._span_name, kind= SpanKind.CLIENT) as self._span:
+                    with tracer.start_as_current_span(
+                        self._span_name, kind=SpanKind.CLIENT
+                    ) as self._span:
                         process_streaming_chat_response(
                             self,
                             pricing_info=pricing_info,
@@ -134,7 +153,7 @@ def async_generate_stream(version, environment, application_name,
                             metrics=metrics,
                             capture_message_content=capture_message_content,
                             disable_metrics=disable_metrics,
-                            version=version
+                            version=version,
                         )
 
                 except Exception as e:
@@ -146,7 +165,9 @@ def async_generate_stream(version, environment, application_name,
         Wraps the GenAI function call.
         """
 
-        server_address, server_port = set_server_address_and_port(instance, "generativelanguage.googleapis.com", 443)
+        server_address, server_port = set_server_address_and_port(
+            instance, "generativelanguage.googleapis.com", 443
+        )
         request_model = kwargs.get("model", "gemini-2.0-flash")
 
         span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"
@@ -154,6 +175,8 @@ def async_generate_stream(version, environment, application_name,
         awaited_wrapped = await wrapped(*args, **kwargs)
         span = tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT)
 
-        return TracedAsyncStream(awaited_wrapped, span, span_name, kwargs, server_address, server_port)
+        return TracedAsyncStream(
+            awaited_wrapped, span, span_name, kwargs, server_address, server_port
+        )
 
     return wrapper

openlit/instrumentation/google_ai_studio/google_ai_studio.py

@@ -4,19 +4,25 @@ Module for monitoring Google AI Studio API calls.
 
 import time
 from opentelemetry.trace import SpanKind
-from openlit.__helpers import (
-    handle_exception,
-    set_server_address_and_port
-)
+from openlit.__helpers import handle_exception, set_server_address_and_port
 from openlit.instrumentation.google_ai_studio.utils import (
     process_chat_response,
     process_chunk,
-    process_streaming_chat_response
+    process_streaming_chat_response,
 )
 from openlit.semcov import SemanticConvention
 
-def generate(version, environment, application_name,
-    tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def generate(
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for GenAI function call
     """
@@ -26,7 +32,9 @@ def generate(version, environment, application_name,
         Wraps the GenAI function call.
         """
 
-        server_address, server_port = set_server_address_and_port(instance, "generativelanguage.googleapis.com", 443)
+        server_address, server_port = set_server_address_and_port(
+            instance, "generativelanguage.googleapis.com", 443
+        )
         request_model = kwargs.get("model", "gemini-2.0-flash")
 
         span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"
@@ -37,22 +45,22 @@ def generate(version, environment, application_name,
 
             try:
                 response = process_chat_response(
-                        instance = instance,
-                        response=response,
-                        request_model=request_model,
-                        pricing_info=pricing_info,
-                        server_port=server_port,
-                        server_address=server_address,
-                        environment=environment,
-                        application_name=application_name,
-                        metrics=metrics,
-                        start_time=start_time,
-                        span=span,
-                        args=args,
-                        kwargs=kwargs,
-                        capture_message_content=capture_message_content,
-                        disable_metrics=disable_metrics,
-                        version=version,
+                    instance=instance,
+                    response=response,
+                    request_model=request_model,
+                    pricing_info=pricing_info,
+                    server_port=server_port,
+                    server_address=server_address,
+                    environment=environment,
+                    application_name=application_name,
+                    metrics=metrics,
+                    start_time=start_time,
+                    span=span,
+                    args=args,
+                    kwargs=kwargs,
+                    capture_message_content=capture_message_content,
+                    disable_metrics=disable_metrics,
+                    version=version,
                 )
 
             except Exception as e:
@@ -63,8 +71,17 @@ def generate(version, environment, application_name,
 
     return wrapper
 
-def generate_stream(version, environment, application_name,
-    tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def generate_stream(
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for GenAI function call
     """
@@ -75,23 +92,23 @@ def generate_stream(version, environment, application_name,
         """
 
         def __init__(
-                self,
-                wrapped,
-                span,
-                span_name,
-                kwargs,
-                server_address,
-                server_port,
-                **args,
-            ):
+            self,
+            wrapped,
+            span,
+            span_name,
+            kwargs,
+            server_address,
+            server_port,
+            **args,
+        ):
             self.__wrapped__ = wrapped
             self._span = span
             self._span_name = span_name
-            self._llmresponse = ''
-            self._finish_reason = ''
-            self._output_tokens = ''
-            self._input_tokens = ''
-            self._response_model = ''
+            self._llmresponse = ""
+            self._finish_reason = ""
+            self._output_tokens = ""
+            self._input_tokens = ""
+            self._response_model = ""
             self._tools = None
 
             self._args = args
@@ -125,7 +142,9 @@ def generate_stream(version, environment, application_name,
                 return chunk
             except StopIteration:
                 try:
-                    with tracer.start_as_current_span(self._span_name, kind= SpanKind.CLIENT) as self._span:
+                    with tracer.start_as_current_span(
+                        self._span_name, kind=SpanKind.CLIENT
+                    ) as self._span:
                         process_streaming_chat_response(
                             self,
                             pricing_info=pricing_info,
@@ -134,7 +153,7 @@ def generate_stream(version, environment, application_name,
                             metrics=metrics,
                             capture_message_content=capture_message_content,
                             disable_metrics=disable_metrics,
-                            version=version
+                            version=version,
                         )
 
                 except Exception as e:
@@ -146,7 +165,9 @@ def generate_stream(version, environment, application_name,
         Wraps the GenAI function call.
         """
 
-        server_address, server_port = set_server_address_and_port(instance, "generativelanguage.googleapis.com", 443)
+        server_address, server_port = set_server_address_and_port(
+            instance, "generativelanguage.googleapis.com", 443
+        )
         request_model = kwargs.get("model", "gemini-2.0-flash")
 
         span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"
@@ -154,6 +175,8 @@ def generate_stream(version, environment, application_name,
         awaited_wrapped = wrapped(*args, **kwargs)
         span = tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT)
 
-        return TracedSyncStream(awaited_wrapped, span, span_name, kwargs, server_address, server_port)
+        return TracedSyncStream(
+            awaited_wrapped, span, span_name, kwargs, server_address, server_port
+        )
 
     return wrapper