openlit 0.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

openlit/__helpers.py

@@ -124,7 +124,7 @@ def get_audio_model_cost(model, pricing_info, prompt):
 
 def fetch_pricing_info():
     """Fetches pricing information from a specified URL."""
-    pricing_url = "https://raw.githubusercontent.com/dokulabs/doku/main/assets/pricing.json"
+    pricing_url = "https://raw.githubusercontent.com/openlit/openlit/main/assets/pricing.json"
     try:
          # Set a timeout of 10 seconds for both the connection and the read
         response = requests.get(pricing_url, timeout=20)

openlit/__init__.py

@@ -17,6 +17,7 @@ from openlit.instrumentation.openai import OpenAIInstrumentor
 from openlit.instrumentation.anthropic import AnthropicInstrumentor
 from openlit.instrumentation.cohere import CohereInstrumentor
 from openlit.instrumentation.mistral import MistralInstrumentor
+from openlit.instrumentation.bedrock import BedrockInstrumentor
 from openlit.instrumentation.langchain import LangChainInstrumentor
 from openlit.instrumentation.chroma import ChromaInstrumentor
 from openlit.instrumentation.pinecone import PineconeInstrumentor
@@ -145,7 +146,8 @@ def init(environment="default", application_name="default", tracer=None, otlp_en
         "openai": "openai",
         "anthropic": "anthropic",  
         "cohere": "cohere",  
-        "mistral": "mistralai",  
+        "mistral": "mistralai",
+        "bedrock": "boto3",
         "langchain": "langchain",
         "chroma": "chromadb",
         "pinecone": "pincone",
@@ -192,6 +194,7 @@ def init(environment="default", application_name="default", tracer=None, otlp_en
             "anthropic": AnthropicInstrumentor(),
             "cohere": CohereInstrumentor(),
             "mistral": MistralInstrumentor(),
+            "bedrock": BedrockInstrumentor(),
             "langchain": LangChainInstrumentor(),
             "chroma": ChromaInstrumentor(),
             "pinecone": PineconeInstrumentor(),

openlit/instrumentation/bedrock/__init__.py

@@ -0,0 +1,41 @@
+# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
+"""Initializer of Auto Instrumentation of AWS Bedrock Functions"""
+
+from typing import Collection
+import importlib.metadata
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from wrapt import wrap_function_wrapper
+
+from openlit.instrumentation.bedrock.bedrock import chat
+
+_instruments = ("boto3 >= 1.34.93",)
+
+class BedrockInstrumentor(BaseInstrumentor):
+    """
+    An instrumentor for AWS Bedrock's client library.
+    """
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        application_name = kwargs.get("application_name", "default_application")
+        environment = kwargs.get("environment", "default_environment")
+        tracer = kwargs.get("tracer")
+        metrics = kwargs.get("metrics_dict")
+        pricing_info = kwargs.get("pricing_info", {})
+        trace_content = kwargs.get("trace_content", False)
+        disable_metrics = kwargs.get("disable_metrics")
+        version = importlib.metadata.version("boto3")
+
+        #sync
+        wrap_function_wrapper(
+            "botocore.client",  
+            "ClientCreator.create_client",  
+            chat("bedrock.invoke_model", version, environment, application_name,
+                     tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+
+    def _uninstrument(self, **kwargs):
+        # Proper uninstrumentation logic to revert patched methods
+        pass

openlit/instrumentation/bedrock/bedrock.py

@@ -0,0 +1,436 @@
+# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument, protected-access, too-many-branches
+"""
+Module for monitoring Amazon Bedrock API calls.
+"""
+
+import logging
+import json
+from botocore.response import StreamingBody
+from botocore.exceptions import ReadTimeoutError, ResponseStreamingError
+from urllib3.exceptions import ProtocolError as URLLib3ProtocolError
+from urllib3.exceptions import ReadTimeoutError as URLLib3ReadTimeoutError
+from opentelemetry.trace import SpanKind, Status, StatusCode
+from opentelemetry.sdk.resources import TELEMETRY_SDK_NAME
+from openlit.__helpers import get_chat_model_cost, get_embed_model_cost, get_image_model_cost
+from openlit.__helpers import handle_exception, general_tokens
+from openlit.semcov import SemanticConvetion
+
+# Initialize logger for logging potential issues and operations
+logger = logging.getLogger(__name__)
+
+class CustomStreamWrapper(StreamingBody):
+    """Handle streaming responses with the ability to read multiple times."""
+
+    def __init__(self, stream_source, length):
+        super().__init__(stream_source, length)
+        self._stream_data = None
+        self._read_position = 0
+
+    def read(self, amt=None):
+        if self._stream_data is None:
+            try:
+                self._stream_data = self._raw_stream.read()
+            except URLLib3ReadTimeoutError as error:
+                raise ReadTimeoutError(endpoint_url=error.url, error=error) from error
+            except URLLib3ProtocolError as error:
+                raise ResponseStreamingError(error=error) from error
+
+            self._amount_read += len(self._stream_data)
+            if amt is None or (not self._stream_data and amt > 0):
+                self._verify_content_length()
+
+        if amt is None:
+            data_chunk = self._stream_data[self._read_position:]
+        else:
+            data_start = self._read_position
+            self._read_position += amt
+            data_chunk = self._stream_data[data_start:self._read_position]
+
+        return data_chunk
+
+
+def chat(gen_ai_endpoint, version, environment, application_name, tracer,
+         pricing_info, trace_content, metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for messages to collect metrics.
+
+    Args:
+        gen_ai_endpoint: Endpoint identifier for logging and tracing.
+        version: The monitoring package version.
+        environment: Deployment environment (e.g. production, staging).
+        application_name: Name of the application using the Bedrock API.
+        tracer: OpenTelemetry tracer for creating spans.
+        pricing_info: Information for calculating Bedrock usage cost.
+        trace_content: Whether to trace the actual content.
+        metrics: Metrics collector.
+        disable_metrics: Flag to toggle metrics collection.
+    Returns:
+        A function that wraps the chat method to add telemetry.
+    """
+
+    def wrapper(wrapped, instance, args, kwargs):
+        """
+        Wraps an API call to add telemetry.
+
+        Args:
+            wrapped: Original method.
+            instance: Instance of the class.
+            args: Positional arguments of the 'messages' method.
+            kwargs: Keyword arguments of the 'messages' method.
+        Returns:
+            Response from the original method.
+        """
+        def handle_image(span, model, request_body, response_body):
+            cost = 0
+            if "amazon" in model:
+                # pylint: disable=line-too-long
+                size =  str(request_body.get("imageGenerationConfig", {}).get("width", 1024)) + "x" + str(request_body.get("imageGenerationConfig", {}).get("height", 1024))
+                quality = request_body.get("imageGenerationConfig", {}).get("quality", "standard")
+                n = request_body.get("imageGenerationConfig", {}).get("numberOfImages", 1)
+
+                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_IMAGE_SIZE,
+                                   size)
+                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_IMAGE_QUALITY,
+                                   quality)
+                # Calculate cost of the operation
+                cost = n * get_image_model_cost(model,
+                                        pricing_info, size, quality)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                            cost)
+                if trace_content:
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
+                                        request_body.get("textToImageParams")["text"])
+
+            span.set_status(Status(StatusCode.OK))
+
+            if disable_metrics is False:
+                attributes = {
+                    TELEMETRY_SDK_NAME:
+                        "openlit",
+                    SemanticConvetion.GEN_AI_APPLICATION_NAME:
+                        application_name,
+                    SemanticConvetion.GEN_AI_SYSTEM:
+                        SemanticConvetion.GEN_AI_SYSTEM_BEDROCK,
+                    SemanticConvetion.GEN_AI_ENVIRONMENT:
+                        environment,
+                    SemanticConvetion.GEN_AI_TYPE:
+                        SemanticConvetion.GEN_AI_TYPE_IMAGE,
+                    SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                        model
+                }
+
+                metrics["genai_requests"].add(1, attributes)
+                metrics["genai_cost"].record(cost, attributes)
+
+        def handle_embed(span, model, request_body, response_body):
+            prompt_tokens, cost = 0, 0
+            if "amazon" in model:
+                prompt_tokens = response_body["inputTextTokenCount"]
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                   prompt_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                   prompt_tokens)
+                # Calculate cost of the operation
+                cost = get_embed_model_cost(model,
+                                        pricing_info, prompt_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                            cost)
+                if trace_content:
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
+                                        request_body["inputText"])
+
+            span.set_status(Status(StatusCode.OK))
+
+            if disable_metrics is False:
+                attributes = {
+                    TELEMETRY_SDK_NAME:
+                        "openlit",
+                    SemanticConvetion.GEN_AI_APPLICATION_NAME:
+                        application_name,
+                    SemanticConvetion.GEN_AI_SYSTEM:
+                        SemanticConvetion.GEN_AI_SYSTEM_BEDROCK,
+                    SemanticConvetion.GEN_AI_ENVIRONMENT:
+                        environment,
+                    SemanticConvetion.GEN_AI_TYPE:
+                        SemanticConvetion.GEN_AI_TYPE_EMBEDDING,
+                    SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                        model
+                }
+
+                metrics["genai_requests"].add(1, attributes)
+                metrics["genai_total_tokens"].add(
+                    prompt_tokens, attributes
+                )
+                metrics["genai_prompt_tokens"].add(prompt_tokens, attributes)
+                metrics["genai_cost"].record(cost, attributes)
+
+        def handle_chat(span, model, request_body, response_body):
+            prompt_tokens, completion_tokens, cost = 0, 0, 0
+
+            if "amazon" in model:
+                prompt_tokens = response_body["inputTextTokenCount"]
+                completion_tokens = response_body["results"][0]["tokenCount"]
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                    prompt_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
+                                    completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                    completion_tokens +
+                                    prompt_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
+                                    response_body["results"][0]["completionReason"])
+
+                # Calculate cost of the operation
+                cost = get_chat_model_cost(model,
+                                        pricing_info, prompt_tokens,
+                                        completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                            cost)
+
+                if trace_content:
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
+                                    request_body["inputText"])
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
+                                    response_body["results"][0]["outputText"])
+
+            elif "mistral" in model:
+                prompt_tokens = general_tokens(request_body["prompt"])
+                completion_tokens = general_tokens(response_body["outputs"][0]["text"])
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                prompt_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
+                                completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                prompt_tokens + completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
+                                    response_body["outputs"][0]["stop_reason"])
+                # Calculate cost of the operation
+                cost = get_chat_model_cost(model,
+                                        pricing_info, prompt_tokens,
+                                        completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                            cost)
+
+                if trace_content:
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
+                                    request_body["prompt"])
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
+                                    response_body["outputs"][0]["text"])
+
+            elif "anthropic" in model:
+                prompt_tokens = response_body["usage"]["input_tokens"]
+                completion_tokens = response_body["usage"]["output_tokens"]
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                    prompt_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
+                                    completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                    completion_tokens +
+                                    prompt_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
+                                    response_body["stop_reason"])
+
+                # Calculate cost of the operation
+                cost = get_chat_model_cost(model,
+                                        pricing_info, prompt_tokens,
+                                        completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                            cost)
+
+                if trace_content:
+                    # Format 'messages' into a single string
+                    message_prompt = request_body["messages"]
+                    formatted_messages = []
+                    for message in message_prompt:
+                        role = message["role"]
+                        content = message["content"]
+
+                        if isinstance(content, list):
+                            content_str = ", ".join(
+                                # pylint: disable=line-too-long
+                                f'{item["type"]}: {item["text"] if "text" in item else item["image_url"]}'
+                                if "type" in item else f'text: {item["text"]}'
+                                for item in content
+                            )
+                            formatted_messages.append(f"{role}: {content_str}")
+                        else:
+                            formatted_messages.append(f"{role}: {content}")
+                    prompt = "\n".join(formatted_messages)
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
+                                    prompt)
+
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
+                                    response_body["content"][0]["text"])
+            elif "meta" in model:
+                prompt_tokens = response_body["prompt_token_count"]
+                completion_tokens = response_body["generation_token_count"]
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                    prompt_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
+                                    completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                    completion_tokens +
+                                    prompt_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
+                                    response_body["stop_reason"])
+
+                # Calculate cost of the operation
+                cost = get_chat_model_cost(model,
+                                        pricing_info, prompt_tokens,
+                                        completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                            cost)
+
+                if trace_content:
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
+                                    request_body["prompt"])
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
+                                    response_body["generation"])
+
+            elif "cohere" in model and "command-r" not in model:
+                prompt_tokens = general_tokens(request_body["prompt"])
+                completion_tokens = general_tokens(response_body["generations"][0]["text"])
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                prompt_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
+                                completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                prompt_tokens + completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
+                                    response_body["generations"][0]["finish_reason"])
+                # Calculate cost of the operation
+                cost = get_chat_model_cost(model,
+                                        pricing_info, prompt_tokens,
+                                        completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                            cost)
+
+                if trace_content:
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
+                                    request_body["prompt"])
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
+                                    response_body["generations"][0]["text"])
+            elif "ai21" in model:
+                prompt_tokens = general_tokens(request_body["prompt"])
+                completion_tokens = general_tokens(response_body["completions"][0]["data"]["text"])
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                prompt_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
+                                completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                prompt_tokens + completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
+                                    response_body["completions"][0]["finishReason"]["reason"])
+                # Calculate cost of the operation
+                cost = get_chat_model_cost(model,
+                                        pricing_info, prompt_tokens,
+                                        completion_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                            cost)
+
+                if trace_content:
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
+                                    request_body["prompt"])
+                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
+                                    response_body["completions"][0]["data"]["text"])
+
+            span.set_status(Status(StatusCode.OK))
+
+            if disable_metrics is False:
+                attributes = {
+                    TELEMETRY_SDK_NAME:
+                        "openlit",
+                    SemanticConvetion.GEN_AI_APPLICATION_NAME:
+                        application_name,
+                    SemanticConvetion.GEN_AI_SYSTEM:
+                        SemanticConvetion.GEN_AI_SYSTEM_BEDROCK,
+                    SemanticConvetion.GEN_AI_ENVIRONMENT:
+                        environment,
+                    SemanticConvetion.GEN_AI_TYPE:
+                        SemanticConvetion.GEN_AI_TYPE_CHAT,
+                    SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                        model
+                }
+
+                metrics["genai_requests"].add(1, attributes)
+                metrics["genai_total_tokens"].add(
+                    prompt_tokens + completion_tokens, attributes
+                )
+                metrics["genai_completion_tokens"].add(completion_tokens, attributes)
+                metrics["genai_prompt_tokens"].add(prompt_tokens, attributes)
+                metrics["genai_cost"].record(cost, attributes)
+
+        def add_instrumentation(original_method, *method_args, **method_kwargs):
+            """
+            Adds instrumentation to the invoke model call.
+
+            Args:
+                original_method: The original invoke model method.
+                *method_args: Positional arguments for the method.
+                **method_kwargs: Keyword arguments for the method.
+            Returns:
+                The modified response with telemetry.
+            """
+            with tracer.start_as_current_span(gen_ai_endpoint, kind=SpanKind.CLIENT) as span:
+                response = original_method(*method_args, **method_kwargs)
+
+                try:
+                    # Modify the response body to be reusable
+                    response["body"] = CustomStreamWrapper(
+                        response["body"]._raw_stream, response["body"]._content_length
+                    )
+                    request_body = json.loads(method_kwargs.get("body"))
+                    response_body = json.loads(response.get("body").read())
+
+                    model = method_kwargs.get("modelId", "amazon.titan-text-express-v1")
+                    if ("stability" in model or "image" in model) and "embed-image" not in model:
+                        generation = "image"
+                        span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                        SemanticConvetion.GEN_AI_TYPE_IMAGE)
+                    elif "embed" in model and "embed-image" not in model:
+                        generation = "embeddings"
+                        span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                        SemanticConvetion.GEN_AI_TYPE_EMBEDDING)
+                    else:
+                        generation = "chat"
+                        span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                        SemanticConvetion.GEN_AI_TYPE_CHAT)
+
+                    span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                    span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                        SemanticConvetion.GEN_AI_SYSTEM_BEDROCK)
+                    span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
+                                        gen_ai_endpoint)
+                    span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                                        environment)
+                    span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                                        application_name)
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
+                                        model)
+                    if generation == "chat":
+                        handle_chat(span, model, request_body, response_body)
+                    elif generation == "embeddings":
+                        handle_embed(span, model, request_body, response_body)
+                    elif generation == "image":
+                        handle_image(span, model, request_body, response_body)
+
+                    return response
+
+                except Exception as e:
+                    handle_exception(span, e)
+                    logger.error("Error in trace creation: %s", e)
+
+                    # Return original response
+                    return response
+
+        # Get the original client instance from the wrapper
+        client = wrapped(*args, **kwargs)
+
+        # Replace the original method with the instrumented one
+        original_invoke_model = client.invoke_model
+        client.invoke_model = lambda *args, **kwargs: add_instrumentation(original_invoke_model,
+                                                                          *args, **kwargs)
+
+        return client
+
+    return wrapper

openlit/otel/metrics.py

@@ -72,7 +72,7 @@ def setup_meter(application_name, environment, meter, otlp_endpoint, otlp_header
         metrics_dict = {
             "genai_requests": meter.create_counter(
                 name=SemanticConvetion.GEN_AI_REQUESTS,
-                description="Number of requests to OpenAI",
+                description="Number of requests to GenAI",
                 unit="1",
             ),
             "genai_prompt_tokens": meter.create_counter(
@@ -92,7 +92,7 @@ def setup_meter(application_name, environment, meter, otlp_endpoint, otlp_header
             ),
             "genai_cost": meter.create_histogram(
                 name=SemanticConvetion.GEN_AI_USAGE_COST,
-                description="The distribution of OpenAI request costs.",
+                description="The distribution of GenAI request costs.",
                 unit="USD",
             ),
             "db_requests": meter.create_counter(

openlit/semcov/__init__.py

@@ -85,6 +85,7 @@ class SemanticConvetion:
     GEN_AI_SYSTEM_ANTHROPIC = "anthropic"
     GEN_AI_SYSTEM_COHERE = "cohere"
     GEN_AI_SYSTEM_MISTRAL = "mistral"
+    GEN_AI_SYSTEM_BEDROCK = "bedrock"
     GEN_AI_SYSTEM_LANGCHAIN = "langchain"
 
     # Vector DB

{openlit-0.0.2.dist-info → openlit-1.1.0.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: openlit
-Version: 0.0.2
+Version: 1.1.0
 Summary: OpenTelemetry-native Auto instrumentation library for monitoring LLM Applications, facilitating the integration of observability into your GenAI-driven projects
-Home-page: https://github.com/open-lit/openlit/tree/main/openlit/python
+Home-page: https://github.com/openlit/openlit/tree/main/openlit/python
 Keywords: OpenTelemetry,otel,otlp,llm,tracing,openai,anthropic,claude,cohere,llm monitoring,observability,monitoring,gpt,Generative AI,chatGPT
 Author: OpenLIT
 Requires-Python: >=3.7.1,<4.0.0
@@ -12,16 +12,33 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: boto3 (>=1.34.0,<2.0.0)
+Requires-Dist: botocore (>=1.34.0,<2.0.0)
 Requires-Dist: opentelemetry-api (>=1.24.0,<2.0.0)
 Requires-Dist: opentelemetry-exporter-otlp (>=1.24.0,<2.0.0)
 Requires-Dist: opentelemetry-instrumentation (>=0.45b0,<0.46)
 Requires-Dist: opentelemetry-sdk (>=1.24.0,<2.0.0)
 Requires-Dist: requests (>=2.26.0,<3.0.0)
 Requires-Dist: tiktoken (>=0.1.1,<0.2.0)
-Project-URL: Repository, https://github.com/open-lit/openlit/tree/main/openlit/python
+Project-URL: Repository, https://github.com/openlit/openlit/tree/main/openlit/python
 Description-Content-Type: text/markdown
 
-# OpenLIT: OpenTelemetry-native Observability for LLMs
+<div align="center">
+<img src="https://github.com/openlit/.github/blob/main/profile/assets/wide-logo-no-bg.png?raw=true" alt="OpenLIT Logo" width="30%"><h1>
+OpenTelemetry Auto-Instrumentation for GenAI & LLM Applications</h1>
+
+**[Documentation](https://docs.openlit.io/) | [Quickstart](#-getting-started) | [Python SDK](https://github.com/openlit/openlit/tree/main/sdk/python)**
+
+[![OpenLIT](https://img.shields.io/badge/OpenLIT-orange)](https://github.com/openlit/openlit)
+[![License](https://img.shields.io/github/license/openlit/openlit?label=License&logo=github&color=f80&logoColor=white)](https://github.com/openlit/openlit/blob/main/LICENSE)
+[![Downloads](https://static.pepy.tech/badge/openlit/month)](https://pepy.tech/project/openlit)
+[![GitHub Last Commit](https://img.shields.io/github/last-commit/openlit/openlit)](https://github.com/openlit/openlit/pulse)
+[![GitHub Contributors](https://img.shields.io/github/contributors/openlit/openlit)](https://github.com/openlit/openlit/graphs/contributors)
+
+[![Slack](https://img.shields.io/badge/Slack-4A154B?logo=slack&logoColor=white)](https://join.slack.com/t/openlit/shared_invite/zt-2etnfttwg-TjP_7BZXfYg84oAukY8QRQ)
+[![X](https://img.shields.io/badge/follow-%40OpenLIT-1DA1F2?logo=x&style=social)](https://twitter.com/openlit_io)
+
+</div>
 
 OpenLIT Python SDK is an **OpenTelemetry-native** Auto instrumentation library for monitoring LLM Applications, facilitating the integration of observability into your GenAI-driven projects. Designed with simplicity and efficiency, OpenLIT offers the ability to embed observability into your GenAI-driven projects effortlessly using just **a single line of code**.
 
@@ -63,10 +80,20 @@ This project adheres to the [Semantic Conventions](https://github.com/open-telem
 pip install openlit
 ```
 
-## ⚡ Quick Integration
+## 🚀 Getting Started
+
+## Step 1: Install OpenLIT SDK
+
+```bash
+pip install openlit
+```
+
+### Step 2: Instrument your Application
+Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**: 
 
 ```python
 import openlit
+
 openlit.init()
 ```
 
@@ -74,6 +101,42 @@ By default, OpenLIT directs traces and metrics straight to your console. To forw
 
 To send telemetry to OpenTelemetry backends requiring authentication, set the `otlp_headers` parameter with its desired value. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_HEADERS` environment variable as recommended in the OpenTelemetry documentation.
 
+#### Example
+
+Here is how you can send telemetry from OpenLIT to Grafana Cloud
+
+```python
+openlit.init(
+  otlp_endpoint="https://otlp-gateway-prod-us-east-0.grafana.net/otlp", 
+  otlp_headers="Authorization=Basic%20<base64 encoded Instance ID and API Token>"
+)
+```
+
+Alternatively, You can also choose to set these values using `OTEL_EXPORTER_OTLP_ENDPOINT` and `OTEL_EXPORTER_OTLP_HEADERS` environment variables
+
+```python
+openlit.init()
+```
+
+```env
+export OTEL_EXPORTER_OTLP_ENDPOINT = "https://otlp-gateway-prod-us-east-0.grafana.net/otlp"
+export OTEL_EXPORTER_OTLP_HEADERS = "Authorization=Basic%20<base64 encoded Instance ID and API Token>"
+```
+
+### Step 3: Visualize and Optimize!
+With the LLM Observability data now being collected and sent to your chosen OpenTelemetry backend, the next step is to visualize and analyze this data to glean insights into your application's performance, behavior, and identify areas of improvement. Here is how you would use the data in Grafana, follow these detailed instructions to explore your LLM application's Telemetry data.
+
+   - Select the **Explore** option from Grafana's sidebar.
+   - At the top, ensure the correct Tempo data source is selected from the dropdown menu.
+   - Use the **Query** field to specify any particular traces you are interested in, or leave it empty to browse through all the available traces.
+   - You can adjust the time range to focus on specific periods of interest.
+   - Hit **Run Query** to fetch your trace data. You'll see a visual representation of your traces along with detailed information on particular spans when clicked.
+
+#### Next Steps
+
+- **Create Dashboards:** Beyond just exploring traces, consider creating dashboards in Grafana to monitor key performance indicators (KPIs) and metrics over time. Dashboards can be customized with various panels to display graphs, logs, and single stats that are most relevant to your application's performance and usage patterns.
+- **Set Alerts:** Grafana also allows you to set up alerts based on specific thresholds. This feature can be invaluable in proactively managing your application's health by notifying you of potential issues before they impact users.
+- **Iterate and Optimize:** Use the insights gained from your observability data to make informed decisions on optimizing your LLM application. This might involve refining model parameters, adjusting scaling strategies, or identifying and resolving bottlenecks.
 
 
 ### Configuration
@@ -107,7 +170,8 @@ Your input helps us grow and improve, and we're here to support you every step o
 
 Connect with the OpenLIT community and maintainers for support, discussions, and updates:
 
-- 🌟 If you like it, Leave a star on our [GitHub](https://github.com/open-lit/openlit/)
+- 🌟 If you like it, Leave a star on our [GitHub](https://github.com/openlit/openlit/)
 - 🌍 Join our [Slack](https://join.slack.com/t/openlit/shared_invite/zt-2etnfttwg-TjP_7BZXfYg84oAukY8QRQ) Community for live interactions and questions.
-- 🐞 Report bugs on our [GitHub Issues](https://github.com/open-lit/openlit/issues) to help us improve OpenLIT.
+- 🐞 Report bugs on our [GitHub Issues](https://github.com/openlit/openlit/issues) to help us improve OpenLIT.
 - 𝕏 Follow us on [X](https://twitter.com/openlit) for the latest updates and news.
+

{openlit-0.0.2.dist-info → openlit-1.1.0.dist-info}/RECORD

@@ -1,8 +1,10 @@
-openlit/__helpers.py,sha256=G-QikEhscZIKxV372EQwW8oEqXKy11okykmvQ6VO_Ys,4649
-openlit/__init__.py,sha256=E1J6QPM0BiQAbOSetZ32yaw-Ikx4ZgvPemMP9XTdxFA,8795
+openlit/__helpers.py,sha256=EEbLEUKuCiBp0WiieAvUnGcaU5D7grFgNVDCBgMKjQE,4651
+openlit/__init__.py,sha256=wUvAHi_LxSKpBVSsrTtzA91dpoa18ftqHB7JUzSgAUU,8931
 openlit/instrumentation/anthropic/__init__.py,sha256=oaU53BOPyfUKbEzYvLr1DPymDluurSnwo4Hernf2XdU,1955
 openlit/instrumentation/anthropic/anthropic.py,sha256=gLN7LrgbTTOxgO8TEn-mX7WCYVGExrIGB-_ueCLPMEY,15993
 openlit/instrumentation/anthropic/async_anthropic.py,sha256=wb5U9aF3FtgPZ_1EZudsuKaB6wmOrEVwDIlfcEWnQqU,16035
+openlit/instrumentation/bedrock/__init__.py,sha256=QPvDMQde6Meodu5JvosHdZsnyExS19lcoP5Li4YrOkw,1540
+openlit/instrumentation/bedrock/bedrock.py,sha256=Q5t5283LGEvhyrUCr9ofEQF22JTkc1UvT2_6u7e7gmA,22278
 openlit/instrumentation/chroma/__init__.py,sha256=61lFpHlUEQUobsUJZHXdvOViKwsOH8AOvSfc4VgCmiM,3253
 openlit/instrumentation/chroma/chroma.py,sha256=wcY5sN-Lfdr4P56FDy8O_ft20gfxTDP12c2vIUF7Qno,10374
 openlit/instrumentation/cohere/__init__.py,sha256=PC5T1qIg9pwLNocBP_WjG5B_6p_z019s8quk_fNLAMs,1920
@@ -21,10 +23,10 @@ openlit/instrumentation/pinecone/__init__.py,sha256=Mv9bElqNs07_JQkYyNnO0wOM3hdb
 openlit/instrumentation/pinecone/pinecone.py,sha256=0C-Dd4YOlBCKQ7vmWvFsvokjFCKCn-snquHp7n12yPM,8732
 openlit/instrumentation/transformers/__init__.py,sha256=9-KLjq-aPTh13gTBYsWltV6hokGwt3mP4759SwsaaCk,1478
 openlit/instrumentation/transformers/transformers.py,sha256=peT0BGskYt7AZ0b93TZ7qECXfZRgDQMasUeamexYdZI,7592
-openlit/otel/metrics.py,sha256=GdlQB1PpNvFAVbCqSTh7A87k6VVb1raHrW0y7xGSuQA,4293
+openlit/otel/metrics.py,sha256=O7NoaDz0bY19mqpE4-0PcKwEe-B-iJFRgOCaanAuZAc,4291
 openlit/otel/tracing.py,sha256=peismkno0YPoRezHPbF5Ycz15_oOBErn_coW1CPspHg,3612
-openlit/semcov/__init__.py,sha256=n7lrz6xOwATtKF8cOWvhjr3JIrZ16sy3DXAW4Li2Q24,5686
-openlit-0.0.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openlit-0.0.2.dist-info/METADATA,sha256=qNG41ZQC_-n7j1C5HqT7F-eQ7KTf1bUoZZm6CHxlH1U,6515
-openlit-0.0.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-openlit-0.0.2.dist-info/RECORD,,
+openlit/semcov/__init__.py,sha256=l8Vd1-HqSOD8d7V_D4HIALBNfHeaI4uYeo-bGiMS5tQ,5724
+openlit-1.1.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openlit-1.1.0.dist-info/METADATA,sha256=I9ovMr25H4pdo_qkIg8YpjbO4pxkV90p7YNeBFaUby0,10535
+openlit-1.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+openlit-1.1.0.dist-info/RECORD,,