langtrace-python-sdk 2.0.3__py3-none-any.whl → 2.0.5__py3-none-any.whl

langtrace_python_sdk/instrumentation/langgraph/patch.py

@@ -22,12 +22,12 @@ from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
 from langtrace_python_sdk.constants.instrumentation.common import (
-    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY, SERVICE_PROVIDERS)
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
+    SERVICE_PROVIDERS,
+)
 
 
-def patch_graph_methods(
-    method_name, tracer, version
-):
+def patch_graph_methods(method_name, tracer, version):
     def traced_method(wrapped, instance, args, kwargs):
         service_provider = SERVICE_PROVIDERS["LANGGRAPH"]
         extra_attributes = baggage.get_baggage(LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY)
@@ -38,7 +38,7 @@ def patch_graph_methods(
             "langtrace.service.type": "framework",
             "langtrace.service.version": version,
             "langtrace.version": "1.0.0",
-            **(extra_attributes if extra_attributes is not None else {})
+            **(extra_attributes if extra_attributes is not None else {}),
         }
 
         attr = get_atrribute_key_value(method_name, args)
@@ -75,39 +75,60 @@ def get_atrribute_key_value(method_name, args):
 
     if "add_node" in method_name:
         return {
-            'langgraph.node': json.dumps({
-                'name': args[0],
-                'action': args[1].json() if hasattr(args[1], 'json') else args[1].__name__ if hasattr(args[1], '__name__') else str(args[1]),
-            }),
-            'langgraph.task.name': 'add_node',
+            "langgraph.node": json.dumps(
+                {
+                    "name": args[0],
+                    "action": (
+                        args[1].json()
+                        if hasattr(args[1], "json")
+                        else (
+                            args[1].__name__
+                            if hasattr(args[1], "__name__")
+                            else str(args[1])
+                        )
+                    ),
+                }
+            ),
+            "langgraph.task.name": "add_node",
         }
     elif "add_edge" in method_name:
         return {
-            'langgraph.edge': json.dumps({
-                'source': args[0],
-                'destination': args[1],
-            }),
-            'langgraph.task.name': 'add_edge',
+            "langgraph.edge": json.dumps(
+                {
+                    "source": args[0],
+                    "destination": args[1],
+                }
+            ),
+            "langgraph.task.name": "add_edge",
         }
     elif "add_conditional_edges" in method_name:
         return {
-            'langgraph.edge': json.dumps({
-                'source': args[0],
-                'path': args[1].json() if hasattr(args[1], 'json') else args[1].__name__ if hasattr(args[1], '__name__') else str(args[1]),
-                'path_map': args[2],
-            }),
-            'langgraph.task.name': 'add_conditional_edges',
+            "langgraph.edge": json.dumps(
+                {
+                    "source": args[0],
+                    "path": (
+                        args[1].json()
+                        if hasattr(args[1], "json")
+                        else (
+                            args[1].__name__
+                            if hasattr(args[1], "__name__")
+                            else str(args[1])
+                        )
+                    ),
+                    "path_map": args[2],
+                }
+            ),
+            "langgraph.task.name": "add_conditional_edges",
         }
     elif "set_entry_point" in method_name:
         return {
-            'langgraph.entrypoint': args[0],
-            'langgraph.task.name': 'set_entry_point',
+            "langgraph.entrypoint": args[0],
+            "langgraph.task.name": "set_entry_point",
         }
     elif "set_finish_point" in method_name:
         return {
-            'langgraph.finishpoint': args[0],
-            'langgraph.task.name': 'set_finish_point',
+            "langgraph.finishpoint": args[0],
+            "langgraph.task.name": "set_finish_point",
         }
     else:
         return None
-

langtrace_python_sdk/instrumentation/llamaindex/patch.py

@@ -20,7 +20,9 @@ from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
 from langtrace_python_sdk.constants.instrumentation.common import (
-    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY, SERVICE_PROVIDERS)
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
+    SERVICE_PROVIDERS,
+)
 
 
 def generic_patch(method, task, tracer, version):

langtrace_python_sdk/instrumentation/openai/instrumentation.py

@@ -23,9 +23,13 @@ from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper
 
 from langtrace_python_sdk.instrumentation.openai.patch import (
-    async_chat_completions_create, async_embeddings_create,
-    async_images_generate, chat_completions_create, embeddings_create,
-    images_generate)
+    async_chat_completions_create,
+    async_embeddings_create,
+    async_images_generate,
+    chat_completions_create,
+    embeddings_create,
+    images_generate,
+)
 
 logging.basicConfig(level=logging.FATAL)
 

langtrace_python_sdk/instrumentation/openai/patch.py

@@ -22,10 +22,11 @@ from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
 from langtrace_python_sdk.constants.instrumentation.common import (
-    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY, SERVICE_PROVIDERS)
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
+    SERVICE_PROVIDERS,
+)
 from langtrace_python_sdk.constants.instrumentation.openai import APIS
-from langtrace_python_sdk.utils.llm import (calculate_prompt_tokens,
-                                            estimate_tokens)
+from langtrace_python_sdk.utils.llm import calculate_prompt_tokens, estimate_tokens
 
 
 def images_generate(original_method, version, tracer):
@@ -52,7 +53,9 @@ def images_generate(original_method, version, tracer):
             "llm.api": APIS["IMAGES_GENERATION"]["ENDPOINT"],
             "llm.model": kwargs.get("model"),
             "llm.stream": kwargs.get("stream"),
-            "llm.prompts": json.dumps([{"role": "user", "content": kwargs.get("prompt", [])}]),
+            "llm.prompts": json.dumps(
+                [{"role": "user", "content": kwargs.get("prompt", [])}]
+            ),
             **(extra_attributes if extra_attributes is not None else {}),
         }
 
@@ -83,7 +86,7 @@ def images_generate(original_method, version, tracer):
                                     if hasattr(data, "revised_prompt")
                                     else ""
                                 ),
-                            }
+                            },
                         }
                     ]
                     span.set_attribute("llm.responses", json.dumps(response))
@@ -127,7 +130,9 @@ def async_images_generate(original_method, version, tracer):
             "llm.api": APIS["IMAGES_GENERATION"]["ENDPOINT"],
             "llm.model": kwargs.get("model"),
             "llm.stream": kwargs.get("stream"),
-            "llm.prompts": json.dumps([{"role": "user", "content": kwargs.get("prompt", [])}]),
+            "llm.prompts": json.dumps(
+                [{"role": "user", "content": kwargs.get("prompt", [])}]
+            ),
             **(extra_attributes if extra_attributes is not None else {}),
         }
 
@@ -159,7 +164,7 @@ def async_images_generate(original_method, version, tracer):
                                     if hasattr(data, "revised_prompt")
                                     else ""
                                 ),
-                            }
+                            },
                         }
                     ]
                     span.set_attribute("llm.responses", json.dumps(response))
@@ -287,7 +292,8 @@ def chat_completions_create(original_method, version, tracer):
                                 if "content_filter_results" in choice
                                 else {}
                             ),
-                        } for choice in result.choices
+                        }
+                        for choice in result.choices
                     ]
                     span.set_attribute("llm.responses", json.dumps(responses))
                 else:
@@ -375,16 +381,22 @@ def chat_completions_create(original_method, version, tracer):
                     elif tool_calls:
                         for choice in chunk.choices:
                             tool_call = ""
-                            if (choice.delta and choice.delta.tool_calls is not None):
+                            if choice.delta and choice.delta.tool_calls is not None:
                                 toolcalls = choice.delta.tool_calls
                                 content = []
                                 for tool_call in toolcalls:
-                                    if tool_call and tool_call.function is not None and tool_call.function.arguments is not None:
+                                    if (
+                                        tool_call
+                                        and tool_call.function is not None
+                                        and tool_call.function.arguments is not None
+                                    ):
                                         token_counts = estimate_tokens(
                                             tool_call.function.arguments
                                         )
                                         completion_tokens += token_counts
-                                        content = content + [tool_call.function.arguments]
+                                        content = content + [
+                                            tool_call.function.arguments
+                                        ]
                                     else:
                                         content = content + []
                 else:
@@ -540,7 +552,8 @@ def async_chat_completions_create(original_method, version, tracer):
                                 if "content_filter_results" in choice
                                 else {}
                             ),
-                        } for choice in result.choices
+                        }
+                        for choice in result.choices
                     ]
                     span.set_attribute("llm.responses", json.dumps(responses))
                 else:
@@ -628,16 +641,22 @@ def async_chat_completions_create(original_method, version, tracer):
                     elif tool_calls:
                         for choice in chunk.choices:
                             tool_call = ""
-                            if (choice.delta and choice.delta.tool_calls is not None):
+                            if choice.delta and choice.delta.tool_calls is not None:
                                 toolcalls = choice.delta.tool_calls
                                 content = []
                                 for tool_call in toolcalls:
-                                    if tool_call and tool_call.function is not None and tool_call.function.arguments is not None:
+                                    if (
+                                        tool_call
+                                        and tool_call.function is not None
+                                        and tool_call.function.arguments is not None
+                                    ):
                                         token_counts = estimate_tokens(
                                             tool_call.function.arguments
                                         )
                                         completion_tokens += token_counts
-                                        content = content + [tool_call.function.arguments]
+                                        content = content + [
+                                            tool_call.function.arguments
+                                        ]
                                     else:
                                         content = content + []
                 else:
@@ -715,13 +734,13 @@ def embeddings_create(original_method, version, tracer):
         }
 
         if kwargs.get("encoding_format") is not None:
-            span_attributes["llm.encoding_format"] = json.dumps([kwargs.get("encoding_format")])
+            span_attributes["llm.encoding.formats"] = json.dumps(
+                [kwargs.get("encoding_format")]
+            )
 
         attributes = LLMSpanAttributes(**span_attributes)
         kwargs.get("encoding_format")
 
-        if kwargs.get("encoding_format") is not None:
-            attributes.llm_encoding_format = kwargs.get("encoding_format")
         if kwargs.get("dimensions") is not None:
             attributes["llm.dimensions"] = kwargs.get("dimensions")
         if kwargs.get("user") is not None:
@@ -776,7 +795,9 @@ def async_embeddings_create(original_method, version, tracer):
             "url.full": base_url,
             "llm.api": APIS["EMBEDDINGS_CREATE"]["ENDPOINT"],
             "llm.model": kwargs.get("model"),
-            "llm.prompts": json.dumps([{"role": "user", "content": kwargs.get("input", "")}]),
+            "llm.prompts": json.dumps(
+                [{"role": "user", "content": kwargs.get("input", "")}]
+            ),
             **(extra_attributes if extra_attributes is not None else {}),
         }
 

langtrace_python_sdk/instrumentation/pinecone/patch.py

@@ -20,7 +20,9 @@ from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
 from langtrace_python_sdk.constants.instrumentation.common import (
-    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY, SERVICE_PROVIDERS)
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
+    SERVICE_PROVIDERS,
+)
 from langtrace_python_sdk.constants.instrumentation.pinecone import APIS
 
 
@@ -41,7 +43,7 @@ def generic_patch(original_method, method, version, tracer):
             "langtrace.version": "1.0.0",
             "db.system": "pinecone",
             "db.operation": api["OPERATION"],
-            **(extra_attributes if extra_attributes is not None else {})
+            **(extra_attributes if extra_attributes is not None else {}),
         }
 
         attributes = DatabaseSpanAttributes(**span_attributes)

langtrace_python_sdk/instrumentation/qdrant/patch.py

@@ -20,7 +20,9 @@ from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
 from langtrace_python_sdk.constants.instrumentation.common import (
-    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY, SERVICE_PROVIDERS)
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
+    SERVICE_PROVIDERS,
+)
 from langtrace_python_sdk.constants.instrumentation.qdrant import APIS
 
 
@@ -42,7 +44,7 @@ def collection_patch(method, version, tracer):
             "langtrace.version": "1.0.0",
             "db.system": "qdrant",
             "db.operation": api["OPERATION"],
-            **(extra_attributes if extra_attributes is not None else {})
+            **(extra_attributes if extra_attributes is not None else {}),
         }
 
         if hasattr(instance, "name") and instance.name is not None:

langtrace_python_sdk/langtrace.py

@@ -16,99 +16,163 @@ limitations under the License.
 
 from typing import Optional
 
+from langtrace_python_sdk.types import DisableInstrumentations, InstrumentationType
 from opentelemetry import trace
 from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import (BatchSpanProcessor,
-                                            ConsoleSpanExporter,
-                                            SimpleSpanProcessor)
-
-from langtrace_python_sdk.extensions.langtrace_exporter import \
-    LangTraceExporter
-from langtrace_python_sdk.instrumentation.anthropic.instrumentation import \
-    AnthropicInstrumentation
-from langtrace_python_sdk.instrumentation.chroma.instrumentation import \
-    ChromaInstrumentation
-from langtrace_python_sdk.instrumentation.cohere.instrumentation import \
-    CohereInstrumentation
-from langtrace_python_sdk.instrumentation.groq.instrumentation import \
-    GroqInstrumentation
-from langtrace_python_sdk.instrumentation.langchain.instrumentation import \
-    LangchainInstrumentation
-from langtrace_python_sdk.instrumentation.langchain_community.instrumentation import \
-    LangchainCommunityInstrumentation
-from langtrace_python_sdk.instrumentation.langchain_core.instrumentation import \
-    LangchainCoreInstrumentation
-from langtrace_python_sdk.instrumentation.langgraph.instrumentation import \
-    LanggraphInstrumentation
-from langtrace_python_sdk.instrumentation.llamaindex.instrumentation import \
-    LlamaindexInstrumentation
-from langtrace_python_sdk.instrumentation.openai.instrumentation import \
-    OpenAIInstrumentation
-from langtrace_python_sdk.instrumentation.pinecone.instrumentation import \
-    PineconeInstrumentation
-from langtrace_python_sdk.instrumentation.qdrant.instrumentation import \
-    QdrantInstrumentation
+from opentelemetry.sdk.trace.export import (
+    BatchSpanProcessor,
+    ConsoleSpanExporter,
+    SimpleSpanProcessor,
+)
+
+from langtrace_python_sdk.extensions.langtrace_exporter import LangTraceExporter
+from langtrace_python_sdk.instrumentation.anthropic.instrumentation import (
+    AnthropicInstrumentation,
+)
+from langtrace_python_sdk.instrumentation.chroma.instrumentation import (
+    ChromaInstrumentation,
+)
+from langtrace_python_sdk.instrumentation.cohere.instrumentation import (
+    CohereInstrumentation,
+)
+from langtrace_python_sdk.instrumentation.groq.instrumentation import (
+    GroqInstrumentation,
+)
+from langtrace_python_sdk.instrumentation.langchain.instrumentation import (
+    LangchainInstrumentation,
+)
+from langtrace_python_sdk.instrumentation.langchain_community.instrumentation import (
+    LangchainCommunityInstrumentation,
+)
+from langtrace_python_sdk.instrumentation.langchain_core.instrumentation import (
+    LangchainCoreInstrumentation,
+)
+from langtrace_python_sdk.instrumentation.langgraph.instrumentation import (
+    LanggraphInstrumentation,
+)
+from langtrace_python_sdk.instrumentation.llamaindex.instrumentation import (
+    LlamaindexInstrumentation,
+)
+from langtrace_python_sdk.instrumentation.openai.instrumentation import (
+    OpenAIInstrumentation,
+)
+from langtrace_python_sdk.instrumentation.pinecone.instrumentation import (
+    PineconeInstrumentation,
+)
+from langtrace_python_sdk.instrumentation.qdrant.instrumentation import (
+    QdrantInstrumentation,
+)
 
 
 def init(
     api_key: str = None,
     batch: bool = True,
-    write_to_langtrace_cloud: bool = True,
+    write_spans_to_console: bool = False,
     custom_remote_exporter=None,
     api_host: Optional[str] = None,
+    disable_instrumentations: Optional[DisableInstrumentations] = {},
 ):
     provider = TracerProvider()
 
     remote_write_exporter = (
-        LangTraceExporter(api_key, write_to_langtrace_cloud, api_host=api_host)
+        LangTraceExporter(api_key=api_key, api_host=api_host)
         if custom_remote_exporter is None
         else custom_remote_exporter
     )
     console_exporter = ConsoleSpanExporter()
     batch_processor_remote = BatchSpanProcessor(remote_write_exporter)
     simple_processor_remote = SimpleSpanProcessor(remote_write_exporter)
-    batch_processor_console = BatchSpanProcessor(console_exporter)
     simple_processor_console = SimpleSpanProcessor(console_exporter)
 
-    if write_to_langtrace_cloud:
-        provider.add_span_processor(batch_processor_remote)
+    if write_spans_to_console:
+        provider.add_span_processor(simple_processor_console)
+
     elif custom_remote_exporter is not None:
         if batch:
             provider.add_span_processor(batch_processor_remote)
         else:
             provider.add_span_processor(simple_processor_remote)
-    else:
+
+    elif api_host is not None:
         if batch:
-            provider.add_span_processor(batch_processor_console)
+            provider.add_span_processor(batch_processor_remote)
         else:
-            provider.add_span_processor(simple_processor_console)
+            provider.add_span_processor(simple_processor_remote)
+    else:
+        provider.add_span_processor(batch_processor_remote)
 
     # Initialize tracer
     trace.set_tracer_provider(provider)
 
-    openai_instrumentation = OpenAIInstrumentation()
-    groq_instrumentation = GroqInstrumentation()
-    pinecone_instrumentation = PineconeInstrumentation()
-    llamaindex_instrumentation = LlamaindexInstrumentation()
-    chroma_instrumentation = ChromaInstrumentation()
-    qdrant_instrumentation = QdrantInstrumentation()
-    langchain_instrumentation = LangchainInstrumentation()
-    langchain_core_instrumentation = LangchainCoreInstrumentation()
-    langchain_community_instrumentation = LangchainCommunityInstrumentation()
-    langgraph_instrumentation = LanggraphInstrumentation()
-    anthropic_instrumentation = AnthropicInstrumentation()
-    cohere_instrumentation = CohereInstrumentation()
-
-    # Call the instrument method with some arguments
-    openai_instrumentation.instrument()
-    groq_instrumentation.instrument()
-    pinecone_instrumentation.instrument()
-    llamaindex_instrumentation.instrument()
-    chroma_instrumentation.instrument()
-    qdrant_instrumentation.instrument()
-    langchain_instrumentation.instrument()
-    langchain_core_instrumentation.instrument()
-    langchain_community_instrumentation.instrument()
-    langgraph_instrumentation.instrument()
-    anthropic_instrumentation.instrument()
-    cohere_instrumentation.instrument()
+    all_instrumentations = {
+        "openai": OpenAIInstrumentation(),
+        "groq": GroqInstrumentation(),
+        "pinecone": PineconeInstrumentation(),
+        "llamaindex": LlamaindexInstrumentation(),
+        "chroma": ChromaInstrumentation(),
+        "qdrant": QdrantInstrumentation(),
+        "langchain": LangchainInstrumentation(),
+        "langchain_core": LangchainCoreInstrumentation(),
+        "langchain_community": LangchainCommunityInstrumentation(),
+        "langgraph": LanggraphInstrumentation(),
+        "anthropic": AnthropicInstrumentation(),
+        "cohere": CohereInstrumentation(),
+    }
+
+    init_instrumentations(disable_instrumentations, all_instrumentations)
+
+
+def init_instrumentations(
+    disable_instrumentations: DisableInstrumentations, all_instrumentations: dict
+):
+    validate_instrumentations(disable_instrumentations)
+
+    for key in disable_instrumentations:
+        for vendor in disable_instrumentations[key]:
+            if key == "only":
+                filtered_dict = {
+                    k: v for k, v in all_instrumentations.items() if k != vendor.value
+                }
+                for _, v in filtered_dict.items():
+                    v.instrument()
+            else:
+                filtered_dict = {
+                    k: v for k, v in all_instrumentations.items() if k == vendor.value
+                }
+
+                for _, v in filtered_dict.items():
+                    v.instrument()
+
+
+def validate_instrumentations(disable_instrumentations):
+
+    if disable_instrumentations is not None:
+        for key, value in disable_instrumentations.items():
+            if isinstance(value, str):
+                # Convert single string to list of enum values
+                disable_instrumentations[key] = [InstrumentationType.from_string(value)]
+            elif isinstance(value, list):
+                # Convert list of strings to list of enum values
+                disable_instrumentations[key] = [
+                    (
+                        InstrumentationType.from_string(item)
+                        if isinstance(item, str)
+                        else item
+                    )
+                    for item in value
+                ]
+            # Validate all items are of enum type
+            if not all(
+                isinstance(item, InstrumentationType)
+                for item in disable_instrumentations[key]
+            ):
+                raise TypeError(
+                    f"All items in {key} must be of type InstrumentationType"
+                )
+        if (
+            disable_instrumentations.get("all_except") is not None
+            and disable_instrumentations.get("only") is not None
+        ):
+            raise ValueError(
+                "Cannot specify both only and all_except in disable_instrumentations"
+            )

langtrace_python_sdk/types/__init__.py

@@ -0,0 +1,29 @@
+from typing import List, TypedDict
+from enum import Enum
+
+
+class InstrumentationType(Enum):
+    OPENAI = "openai"
+    COHERE = "cohere"
+    ANTHROPIC = "anthropic"
+    GROQ = "groq"
+    PINECONE = "pinecone"
+    LLAMAINDEX = "llamaindex"
+    CHROMADB = "chromadb"
+    QDRANT = "qdrant"
+    LANGCHAIN = "langchain"
+    LANGCHAIN_CORE = "langchain_core"
+    LANGCHAIN_COMMUNITY = "langchain_community"
+    LANGGRAPH = "langgraph"
+
+    @staticmethod
+    def from_string(value: str):
+        try:
+            return InstrumentationType[value.upper()]
+        except KeyError:
+            raise ValueError(f"Invalid value for InstrumentationType: {value}")
+
+
+class DisableInstrumentations(TypedDict, total=False):
+    all_except: List[InstrumentationType]
+    only: List[InstrumentationType]

langtrace_python_sdk/utils/llm.py

@@ -16,10 +16,8 @@ limitations under the License.
 
 from tiktoken import get_encoding
 
-from langtrace_python_sdk.constants.instrumentation.common import \
-    TIKTOKEN_MODEL_MAPPING
-from langtrace_python_sdk.constants.instrumentation.openai import \
-    OPENAI_COST_TABLE
+from langtrace_python_sdk.constants.instrumentation.common import TIKTOKEN_MODEL_MAPPING
+from langtrace_python_sdk.constants.instrumentation.openai import OPENAI_COST_TABLE
 
 
 def estimate_tokens(prompt):

langtrace_python_sdk/utils/with_root_span.py

@@ -14,15 +14,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-
 import asyncio
 from functools import wraps
 
 from opentelemetry import baggage, context, trace
 from opentelemetry.trace import SpanKind
 
-from langtrace_python_sdk.constants.instrumentation.common import \
-    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY
+from langtrace_python_sdk.constants.instrumentation.common import (
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
+)
 
 
 def with_langtrace_root_span(

langtrace_python_sdk/version.py

@@ -1 +1 @@
-__version__ = "2.0.3"
+__version__ = "2.0.5"

{langtrace_python_sdk-2.0.3.dist-info → langtrace_python_sdk-2.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 2.0.3
+Version: 2.0.5
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>
@@ -149,7 +149,7 @@ pip install langtrace-python-sdk
 
 ``` python
 from langtrace_python_sdk import langtrace # Must precede any llm module imports
-langtrace.init(write_to_langtrace_cloud=False)
+langtrace.init(write_spans_to_console=True)
 ```
 
 ## Langtrace self hosted custom exporter