monocle-apptrace 0.3.1__tar.gz → 0.4.0b1__tar.gz

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/.gitignore

@@ -13,4 +13,5 @@ dist
 .tox
 .DS_Store
 Pipfile**
-launch.json
+launch.json
+monocle_trace**.json

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/CHANGELOG.md

@@ -1,3 +1,16 @@
+## Version 0.4.0b1 (2025-05-14)
+
+- Added conversation id in scope for teams ai bot ([#180](https://github.com/monocle2ai/monocle/pull/180))
+- Update inference entity type of TeamsAI SDK ([#178](https://github.com/monocle2ai/monocle/pull/178))
+- Added stream and async for openai ([#177](https://github.com/monocle2ai/monocle/pull/177))
+- Update inference span of TeamsAI ([#176](https://github.com/monocle2ai/monocle/pull/176))
+- Remove Preset span name and Bugfix for Event ([#175](https://github.com/monocle2ai/monocle/pull/175))
+- Add haystack anthropic sample ([#174](https://github.com/monocle2ai/monocle/pull/174))
+- aiohttp auto instrumentation ([#173](https://github.com/monocle2ai/monocle/pull/173))
+- Add source path to spans and fix json syntax in file exporter ([#172](https://github.com/monocle2ai/monocle/pull/172))
+- Added changes for openai streaming ([#171](https://github.com/monocle2ai/monocle/pull/171))
+- Add llama index anthropic sample ([#170](https://github.com/monocle2ai/monocle/pull/170))
+
 ## Version 0.3.1 (2024-04-18)
 
 - Add MetaModel for Anthropic SDK ([#159](https://github.com/monocle2ai/monocle/pull/159))
@@ -9,7 +22,7 @@
 - Support monocle exporter list as parameter to `setup_monocle_telemetry()` ([#161](https://github.com/monocle2ai/monocle/pull/161))
 - Add langchain anthropic sample ([#165](https://github.com/monocle2ai/monocle/pull/165))
 
-## Version 0.3.0 (2024-12-10)
+## Version 0.3.0 (2024-03-18)
 
 - Fixed issue with passing context in async case ([#150](https://github.com/monocle2ai/monocle/pull/150))
 - Added lambda processor ([#148](https://github.com/monocle2ai/monocle/pull/148))

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monocle_apptrace
-Version: 0.3.1
+Version: 0.4.0b1
 Summary: package with monocle genAI tracing
 Project-URL: Homepage, https://github.com/monocle2ai/monocle
 Project-URL: Issues, https://github.com/monocle2ai/monocle/issues

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "monocle_apptrace"
-version = "0.3.1"
+version = "0.4.0b1"
 authors = []
 description = "package with monocle genAI tracing"
 readme = "README.md"

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/exporters/aws/s3_exporter.py

@@ -129,6 +129,8 @@ class S3SpanExporter(SpanExporterBase):
             # Serialize spans to JSON or any other format you prefer
             valid_json_list = []
             for span in spans:
+                if self.skip_export(span):
+                    continue
                 try:
                     valid_json_list.append(span.to_json(indent=0).replace("\n", ""))
                 except json.JSONDecodeError as e:
@@ -169,7 +171,7 @@ class S3SpanExporter(SpanExporterBase):
             Key=file_name,
             Body=span_data_batch
         )
-        logger.info(f"Span batch uploaded to AWS S3 as {file_name}.")
+        logger.debug(f"Span batch uploaded to AWS S3 as {file_name}.")
 
     async def force_flush(self, timeout_millis: int = 30000) -> bool:
         await self.__export_spans()  # Export any remaining spans in the queue

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/exporters/azure/blob_exporter.py

@@ -82,8 +82,8 @@ class AzureBlobSpanExporter(SpanExporterBase):
             # With Monocle,OpenTelemetry is always loaded. If the Azure trace package is installed, then it triggers the blob trace generation on every blob operation.
             # Thus, the Monocle span write ends up generating a blob span which again comes back to the exporter .. and would result in an infinite loop.
             # To avoid this, we check if the span has the Monocle SDK version attribute and skip it if it doesn't. That way the blob span genearted by Azure library are not exported.
-            if not span.attributes.get(MONOCLE_SDK_VERSION):
-                continue # TODO: All exporters to use same base class and check it there
+            if self.skip_export(span):
+                continue
             self.export_queue.append(span)
             if len(self.export_queue) >= self.max_batch_size:
                 await self.__export_spans()

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/exporters/base_exporter.py

@@ -1,20 +1,21 @@
-import time
+import time, os
 import random
 import logging
 from abc import ABC, abstractmethod
 from opentelemetry.sdk.trace import ReadableSpan
-from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+from opentelemetry.sdk.trace.export import SpanExportResult
+from monocle_apptrace.instrumentation.common.constants import MONOCLE_SDK_VERSION
 from typing import Sequence
-import asyncio
 
 logger = logging.getLogger(__name__)
 
 class SpanExporterBase(ABC):
-    def __init__(self):
+    def __init__(self, export_monocle_only: bool = True):
         self.backoff_factor = 2
         self.max_retries = 10
         self.export_queue = []
         self.last_export_time = time.time()
+        self.export_monocle_only = export_monocle_only or os.environ.get("MONOCLE_EXPORTS_ONLY", True)
 
     @abstractmethod
     async def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
@@ -27,6 +28,11 @@ class SpanExporterBase(ABC):
     def shutdown(self) -> None:
         pass
 
+    def skip_export(self, span:ReadableSpan) -> bool:
+        if self.export_monocle_only and (not span.attributes.get(MONOCLE_SDK_VERSION)):
+            return True
+        return False
+
     @staticmethod
     def retry_with_backoff(retries=3, backoff_in_seconds=1, max_backoff_in_seconds=32, exceptions=(Exception,)):
         def decorator(func):

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/exporters/file_exporter.py

@@ -7,12 +7,13 @@ from typing import Optional, Callable, Sequence
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 from opentelemetry.sdk.resources import SERVICE_NAME
+from monocle_apptrace.exporters.base_exporter import SpanExporterBase
 from monocle_apptrace.exporters.exporter_processor import ExportTaskProcessor
 
 DEFAULT_FILE_PREFIX:str = "monocle_trace_"
 DEFAULT_TIME_FORMAT:str = "%Y-%m-%d_%H.%M.%S"
 
-class FileSpanExporter(SpanExporter):
+class FileSpanExporter(SpanExporterBase):
     current_trace_id: int = None
     current_file_path: str = None
 
@@ -28,6 +29,7 @@ class FileSpanExporter(SpanExporter):
         + linesep,
         task_processor: Optional[ExportTaskProcessor] = None
     ):
+        super().__init__()
         self.out_handle:TextIOWrapper = None
         self.formatter = formatter
         self.service_name = service_name
@@ -39,21 +41,32 @@ class FileSpanExporter(SpanExporter):
             self.task_processor.start()
 
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        is_root_span = any(not span.parent for span in spans)
         if self.task_processor is not None and callable(getattr(self.task_processor, 'queue_task', None)):
             # Check if any span is a root span (no parent)
-            is_root_span = any(not span.parent for span in spans)
             self.task_processor.queue_task(self._process_spans, spans, is_root_span)
             return SpanExportResult.SUCCESS
         else:
-            return self._process_spans(spans)
+            return self._process_spans(spans, is_root_span=is_root_span)
 
     def _process_spans(self, spans: Sequence[ReadableSpan], is_root_span: bool = False) -> SpanExportResult:
+        first_span:bool = True
         for span in spans:
+            if self.skip_export(span):
+                continue
             if span.context.trace_id != self.current_trace_id:
                 self.rotate_file(span.resource.attributes[SERVICE_NAME],
                                 span.context.trace_id)
+                first_span = True
+            if first_span:
+                first_span = False
+            else:
+                self.out_handle.write(",")
             self.out_handle.write(self.formatter(span))
-        self.out_handle.flush()
+        if is_root_span:
+            self.reset_handle()
+        else:
+            self.out_handle.flush()
         return SpanExportResult.SUCCESS
 
     def rotate_file(self, trace_name:str, trace_id:int) -> None:
@@ -62,6 +75,7 @@ class FileSpanExporter(SpanExporter):
                         self.file_prefix + trace_name + "_" + hex(trace_id) + "_"
                         + datetime.now().strftime(self.time_format) + ".json")
         self.out_handle = open(self.current_file_path, "w", encoding='UTF-8')
+        self.out_handle.write("[")
         self.current_trace_id = trace_id
 
     def force_flush(self, timeout_millis: int = 30000) -> bool:
@@ -70,6 +84,7 @@ class FileSpanExporter(SpanExporter):
 
     def reset_handle(self) -> None:
         if self.out_handle is not None:
+            self.out_handle.write("]")
             self.out_handle.close()
             self.out_handle = None
 

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/exporters/monocle_exporters.py

@@ -1,6 +1,6 @@
 from typing import Dict, Any, List
 import os
-import logging
+import logging, warnings
 from importlib import import_module
 from opentelemetry.sdk.trace.export import SpanExporter, ConsoleSpanExporter
 from monocle_apptrace.exporters.exporter_processor import LambdaExportTaskProcessor, is_aws_lambda_environment
@@ -34,7 +34,7 @@ def get_monocle_exporter(exporters_list:str=None) -> List[SpanExporter]:
         try:
             exporter_class_path = monocle_exporters[exporter_name]
         except KeyError:
-            logger.debug(f"Unsupported Monocle span exporter '{exporter_name}', skipping.")
+            warnings.warn(f"Unsupported Monocle span exporter '{exporter_name}', skipping.")
             continue
         try:
             exporter_module = import_module(exporter_class_path["module"])
@@ -45,7 +45,7 @@ def get_monocle_exporter(exporters_list:str=None) -> List[SpanExporter]:
             else:
                 exporters.append(exporter_class())
         except Exception as ex:
-            logger.debug(
+            warnings.warn(
                 f"Unable to initialize Monocle span exporter '{exporter_name}', error: {ex}. Using ConsoleSpanExporter as a fallback.")
             exporters.append(ConsoleSpanExporter())
             continue

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/exporters/okahu/okahu_exporter.py

@@ -6,7 +6,7 @@ import requests
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult, ConsoleSpanExporter
 from requests.exceptions import ReadTimeout
-
+from monocle_apptrace.exporters.base_exporter import SpanExporterBase
 from monocle_apptrace.exporters.exporter_processor import ExportTaskProcessor
 
 REQUESTS_SUCCESS_STATUS_CODES = (200, 202)
@@ -15,7 +15,7 @@ OKAHU_PROD_INGEST_ENDPOINT = "https://ingest.okahu.co/api/v1/trace/ingest"
 logger = logging.getLogger(__name__)
 
 
-class OkahuSpanExporter(SpanExporter):
+class OkahuSpanExporter(SpanExporterBase):
     def __init__(
             self,
             endpoint: Optional[str] = None,
@@ -24,6 +24,7 @@ class OkahuSpanExporter(SpanExporter):
             task_processor: ExportTaskProcessor = None
     ):
         """Okahu exporter."""
+        super().__init__()
         okahu_endpoint: str = os.environ.get("OKAHU_INGESTION_ENDPOINT", OKAHU_PROD_INGEST_ENDPOINT)
         self.endpoint = endpoint or okahu_endpoint
         api_key: str = os.environ.get("OKAHU_API_KEY")
@@ -58,6 +59,8 @@ class OkahuSpanExporter(SpanExporter):
 
         # append the batch object with all the spans object
         for span in spans:
+            if self.skip_export(span):
+                continue
             # create a object from serialized span
             obj = json.loads(span.to_json())
             if obj["parent_id"] is None:

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/instrumentation/common/constants.py

@@ -51,7 +51,9 @@ llm_type_map = {
     "openaigenerator": "openai",
     "bedrockruntime":"aws_bedrock",
     "sagemakerruntime":"aws_sagemaker",
+    "anthropic": "anthropic",
     "chatanthropic":"anthropic",
+    "anthropicchatgenerator":"anthropic",
 }
 
 MONOCLE_INSTRUMENTOR = "monocle_apptrace"
@@ -74,4 +76,6 @@ WORKFLOW_TYPE_KEY = "monocle.workflow_type"
 ADD_NEW_WORKFLOW = "monocle.add_new_workflow"
 WORKFLOW_TYPE_GENERIC = "workflow.generic"
 MONOCLE_SDK_VERSION = "monocle_apptrace.version"
-MONOCLE_SDK_LANGUAGE = "monocle_apptrace.language"
+MONOCLE_SDK_LANGUAGE = "monocle_apptrace.language"
+MONOCLE_DETECTED_SPAN_ERROR = "monocle_apptrace.detected_span_error"
+HTTP_SUCCESS_CODES = ('200', '201', '202', '204', '205', '206')

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/instrumentation/common/instrumentor.py

@@ -25,9 +25,9 @@ from monocle_apptrace.instrumentation.common.wrapper_method import (
     WrapperMethod,
     MONOCLE_SPAN_HANDLERS
 )
-from monocle_apptrace.instrumentation.common.wrapper import scope_wrapper, ascope_wrapper, wrapper_processor
+from monocle_apptrace.instrumentation.common.wrapper import scope_wrapper, ascope_wrapper, monocle_wrapper, amonocle_wrapper
 from monocle_apptrace.instrumentation.common.utils import (
-    set_scope, remove_scope, http_route_handler, load_scopes, async_wrapper, http_async_route_handler
+    set_scope, remove_scope, http_route_handler, load_scopes, http_async_route_handler
 )
 from monocle_apptrace.instrumentation.common.constants import MONOCLE_INSTRUMENTOR, WORKFLOW_TYPE_GENERIC
 from functools import wraps
@@ -68,13 +68,20 @@ class MonocleInstrumentor(BaseInstrumentor):
 
     def get_instrumentor(self, tracer):
         def instrumented_endpoint_invoke(to_wrap,wrapped, span_name, instance,fn):
-            @wraps(fn)
-            def with_instrumentation(*args, **kwargs):
-                async_task = inspect.iscoroutinefunction(fn)
-                boto_method_to_wrap = to_wrap.copy()
-                boto_method_to_wrap['skip_span'] = False
-                return wrapper_processor(async_task, tracer, NonFrameworkSpanHandler(),
-                            boto_method_to_wrap, fn, instance, args, kwargs)
+            if inspect.iscoroutinefunction(fn):
+                @wraps(fn)
+                async def with_instrumentation(*args, **kwargs):
+                    boto_method_to_wrap = to_wrap.copy()
+                    boto_method_to_wrap['skip_span'] = False
+                    return await amonocle_wrapper(tracer, NonFrameworkSpanHandler(),
+                            boto_method_to_wrap, fn, instance, "", args, kwargs)
+            else:
+                @wraps(fn)
+                def with_instrumentation(*args, **kwargs):
+                    boto_method_to_wrap = to_wrap.copy()
+                    boto_method_to_wrap['skip_span'] = False
+                    return monocle_wrapper(tracer, NonFrameworkSpanHandler(),
+                            boto_method_to_wrap, fn, instance, "", args, kwargs)
             return with_instrumentation
         return instrumented_endpoint_invoke
 
@@ -241,8 +248,8 @@ def start_trace():
         SpanHandler.set_workflow_properties(span)
         token = attach(updated_span_context)
         return token
-    except:
-        logger.warning("Failed to start trace")
+    except Exception as e:
+        logger.warning("Failed to start trace {e}")
         return None
 
 def stop_trace(token) -> None:
@@ -328,8 +335,12 @@ def monocle_trace_scope_method(scope_name: str, scope_value:str=None):
         if inspect.iscoroutinefunction(func):
             @wraps(func)
             async def wrapper(*args, **kwargs):
-                result = async_wrapper(func, scope_name, scope_value, None, *args, **kwargs)
-                return result
+                token = start_scope(scope_name, scope_value)
+                try:
+                    result = await func(*args, **kwargs)
+                    return result
+                finally:
+                    stop_scope(token)
             return wrapper
         else:
             @wraps(func)

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/instrumentation/common/span_handler.py

@@ -8,7 +8,7 @@ from monocle_apptrace.instrumentation.common.constants import (
     QUERY,
     service_name_map,
     service_type_map,
-    MONOCLE_SDK_VERSION, MONOCLE_SDK_LANGUAGE
+    MONOCLE_SDK_VERSION, MONOCLE_SDK_LANGUAGE, MONOCLE_DETECTED_SPAN_ERROR
 )
 from monocle_apptrace.instrumentation.common.utils import set_attribute, get_scopes, MonocleSpanException, get_monocle_version
 from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY, WORKFLOW_TYPE_GENERIC
@@ -18,7 +18,8 @@ logger = logging.getLogger(__name__)
 WORKFLOW_TYPE_MAP = {
     "llama_index": "workflow.llamaindex",
     "langchain": "workflow.langchain",
-    "haystack": "workflow.haystack"
+    "haystack": "workflow.haystack",
+    "teams.ai": "workflow.teams_ai",
 }
 
 class SpanHandler:
@@ -49,10 +50,11 @@ class SpanHandler:
             set_attribute(QUERY, args[0]['prompt_builder']['question'])
 
     @staticmethod
-    def set_default_monocle_attributes(span: Span):
+    def set_default_monocle_attributes(span: Span, source_path = "" ):
         """ Set default monocle attributes for all spans """
         span.set_attribute(MONOCLE_SDK_VERSION, get_monocle_version())
         span.set_attribute(MONOCLE_SDK_LANGUAGE, "python")
+        span.set_attribute("span_source", source_path)
         for scope_key, scope_value in get_scopes().items():
             span.set_attribute(f"scope.{scope_key}", scope_value)
 
@@ -62,8 +64,6 @@ class SpanHandler:
         SpanHandler.set_workflow_attributes(to_wrap, span)
         SpanHandler.set_app_hosting_identifier_attribute(span)
 
-        span.set_status(StatusCode.OK)
-
     @staticmethod
     def set_non_workflow_properties(span: Span, to_wrap = None):
         workflow_name = SpanHandler.get_workflow_name(span=span)
@@ -74,11 +74,14 @@ class SpanHandler:
         if span.status.status_code == StatusCode.UNSET:
             span.set_status(StatusCode.OK)
 
-    def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span):
-        self.hydrate_attributes(to_wrap, wrapped, instance, args, kwargs, result, span)
-        self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, result, span)
+    def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span) -> bool:
+        detected_error_in_attribute = self.hydrate_attributes(to_wrap, wrapped, instance, args, kwargs, result, span)
+        detected_error_in_event = self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, result, span)
+        if detected_error_in_attribute or detected_error_in_event:
+            span.set_attribute(MONOCLE_DETECTED_SPAN_ERROR, True)
 
-    def hydrate_attributes(self, to_wrap, wrapped, instance, args, kwargs, result, span):
+    def hydrate_attributes(self, to_wrap, wrapped, instance, args, kwargs, result, span:Span) -> bool:
+        detected_error:bool = False
         span_index = 0
         if SpanHandler.is_root_span(span):
             span_index = 2 # root span will have workflow and hosting entities pre-populated
@@ -86,7 +89,7 @@ class SpanHandler:
                 'output_processor' in to_wrap and to_wrap["output_processor"] is not None):
             output_processor=to_wrap['output_processor']
             if 'type' in output_processor:
-                        span.set_attribute("span.type", output_processor['type'])
+                span.set_attribute("span.type", output_processor['type'])
             else:
                 logger.warning("type of span not found or incorrect written in entity json")
             if 'attributes' in output_processor:
@@ -104,6 +107,7 @@ class SpanHandler:
                                     span.set_attribute(attribute_name, result)
                             except MonocleSpanException as e:
                                 span.set_status(StatusCode.ERROR, e.message)
+                                detected_error = True
                             except Exception as e:
                                 logger.debug(f"Error processing accessor: {e}")
                         else:
@@ -121,13 +125,14 @@ class SpanHandler:
         
         if span_index > 0:
             span.set_attribute("entity.count", span_index)
+        return detected_error
 
-
-    def hydrate_events(self, to_wrap, wrapped, instance, args, kwargs, result, span):
+    def hydrate_events(self, to_wrap, wrapped, instance, args, kwargs, ret_result, span) -> bool:
+        detected_error:bool = False
         if not self.skip_processor(to_wrap, wrapped, instance, args, kwargs) and (
                 'output_processor' in to_wrap and to_wrap["output_processor"] is not None):
             output_processor=to_wrap['output_processor']
-            arguments = {"instance": instance, "args": args, "kwargs": kwargs, "result": result}
+            arguments = {"instance": instance, "args": args, "kwargs": kwargs, "result": ret_result}
             if 'events' in output_processor:
                 events = output_processor['events']
                 for event in events:
@@ -139,15 +144,25 @@ class SpanHandler:
                         accessor = attribute.get("accessor")
                         if accessor:
                             try:
-                                if attribute_key is not None:
-                                    event_attributes[attribute_key] = accessor(arguments)
-                                else:
-                                    event_attributes.update(accessor(arguments))
+                                result = accessor(arguments)
+                                if result and isinstance(result, dict):
+                                    result = dict((key, value) for key, value in result.items() if value is not None)
+                                if result and isinstance(result, (str, list, dict)):
+                                    if attribute_key is not None:
+                                        event_attributes[attribute_key] = result
+                                    else:
+                                        event_attributes.update(result)
                             except MonocleSpanException as e:
                                 span.set_status(StatusCode.ERROR, e.message)
+                                detected_error = True
                             except Exception as e:
                                 logger.debug(f"Error evaluating accessor for attribute '{attribute_key}': {e}")
-                    span.add_event(name=event_name, attributes=event_attributes)
+                    matching_timestamp = getattr(ret_result, "timestamps", {}).get(event_name, None)
+                    if isinstance(matching_timestamp, int):
+                        span.add_event(name=event_name, attributes=event_attributes, timestamp=matching_timestamp)
+                    else:
+                        span.add_event(name=event_name, attributes=event_attributes)
+        return detected_error
 
     @staticmethod
     def set_workflow_attributes(to_wrap, span: Span):

{monocle_apptrace-0.3.1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/instrumentation/common/utils.py

@@ -1,13 +1,13 @@
 import logging, json
 import os
+import traceback
 from typing import Callable, Generic, Optional, TypeVar, Mapping
-import threading, asyncio
 
 from opentelemetry.context import attach, detach, get_current, get_value, set_value, Context
-from opentelemetry.trace import NonRecordingSpan, Span, get_tracer
+from opentelemetry.trace import NonRecordingSpan, Span
 from opentelemetry.trace.propagation import _SPAN_KEY
 from opentelemetry.sdk.trace import id_generator, TracerProvider
-from opentelemetry.propagate import inject, extract
+from opentelemetry.propagate import extract
 from opentelemetry import baggage
 from monocle_apptrace.instrumentation.common.constants import MONOCLE_SCOPE_NAME_PREFIX, SCOPE_METHOD_FILE, SCOPE_CONFIG_PATH, llm_type_map, MONOCLE_SDK_VERSION, ADD_NEW_WORKFLOW
 from importlib.metadata import version
@@ -17,7 +17,6 @@ U = TypeVar('U')
 
 logger = logging.getLogger(__name__)
 
-monocle_tracer_provider: TracerProvider = None
 embedding_model_context = {}
 scope_id_generator = id_generator.RandomIdGenerator()
 http_scopes:dict[str:str] = {}
@@ -43,14 +42,6 @@ class MonocleSpanException(Exception):
         """String representation of the exception."""
         return f"[Monocle Span Error: {self.message} {self.status}"
 
-def set_tracer_provider(tracer_provider: TracerProvider):
-    global monocle_tracer_provider
-    monocle_tracer_provider = tracer_provider
-
-def get_tracer_provider() -> TracerProvider:
-    global monocle_tracer_provider
-    return monocle_tracer_provider
-
 def set_span_attribute(span, name, value):
     if value is not None:
         if value != "":
@@ -93,7 +84,12 @@ def with_tracer_wrapper(func):
             except Exception as e:
                 logger.error("Exception in attaching parent context: %s", e)
 
-            val = func(tracer, handler, to_wrap, wrapped, instance, args, kwargs)
+            if traceback.extract_stack().__len__() > 2:
+                filename, line_number, _, _ = traceback.extract_stack()[-2]
+                source_path = f"{filename}:{line_number}"
+            else:
+                source_path = ""
+            val = func(tracer, handler, to_wrap, wrapped, instance, source_path, args, kwargs)
             return val
 
         return wrapper
@@ -275,49 +271,44 @@ async def http_async_route_handler(func, *args, **kwargs):
         headers = kwargs['req'].headers
     else:
         headers = None
-    return async_wrapper(func, None, None, headers, *args, **kwargs)
-
-def run_async_with_scope(method, current_context, exceptions, *args, **kwargs):
-    token = None
     try:
-        if current_context:
-            token = attach(current_context)
-        return asyncio.run(method(*args, **kwargs))
-    except Exception as e:
-        exceptions['exception'] = e
-        raise e
+        if headers is not None:
+            token = extract_http_headers(headers)
+        return await func(*args, **kwargs)
     finally:
-        if token:
-            detach(token)
+        if token is not None:
+            clear_http_scopes(token)
 
-def async_wrapper(method, scope_name=None, scope_value=None, headers=None, *args, **kwargs):
-    try:
-        run_loop = asyncio.get_running_loop()
-    except RuntimeError:
-        run_loop = None
-
-    token = None
-    exceptions = {}
-    if scope_name:
-        token = set_scope(scope_name, scope_value)
-    elif headers:
-        token = extract_http_headers(headers)
-    current_context = get_current()
-    try:
-        if run_loop and run_loop.is_running():
-            results = []
-            thread = threading.Thread(target=lambda: results.append(run_async_with_scope(method, current_context, exceptions, *args, **kwargs)))
-            thread.start()
-            thread.join()
-            if 'exception' in exceptions:
-                raise exceptions['exception']
-            return_value = results[0] if len(results) > 0 else None
-            return return_value
-        else:
-            return run_async_with_scope(method, None, exceptions, *args, **kwargs)
-    finally:
-        if token:
-            remove_scope(token)
+# def run_async_with_scope(method, current_context, exceptions, *args, **kwargs):
+#     token = None
+#     try:
+#         if current_context:
+#             token = attach(current_context)
+#         return asyncio.run(method(*args, **kwargs))
+#     except Exception as e:
+#         exceptions['exception'] = e
+#         raise e
+#     finally:
+#         if token:
+#             detach(token)
+
+# async def async_wrapper(method, headers=None, *args, **kwargs):
+#     current_context = get_current()
+#     try:
+#         if run_loop and run_loop.is_running():
+#             results = []
+#             thread = threading.Thread(target=lambda: results.append(run_async_with_scope(method, current_context, exceptions, *args, **kwargs)))
+#             thread.start()
+#             thread.join()
+#             if 'exception' in exceptions:
+#                 raise exceptions['exception']
+#             return_value = results[0] if len(results) > 0 else None
+#             return return_value
+#         else:
+#             return run_async_with_scope(method, None, exceptions, *args, **kwargs)
+#     finally:
+#         if token:
+#             remove_scope(token)
 
 def get_monocle_version() -> str:
     global monocle_sdk_version
@@ -365,7 +356,24 @@ def try_option(func: Callable[..., T], *args, **kwargs) -> Option[T]:
 def get_llm_type(instance):
     try:
         t_name = type(instance).__name__.lower()
-        llm_type = llm_type_map.get(type(instance).__name__.lower())
+        t_name = t_name.replace("async", "") if "async" in t_name else t_name
+        llm_type = llm_type_map.get(t_name)
         return llm_type
     except:
         pass
+
+def patch_instance_method(obj, method_name, func):
+    """
+    Patch a special method (like __iter__) for a single instance.
+
+    Args:
+        obj: the instance to patch
+        method_name: the name of the method (e.g., '__iter__')
+        func: the new function, expecting (self, ...)
+    """
+    cls = obj.__class__
+    # Dynamically create a new class that inherits from obj's class
+    new_cls = type(f"Patched{cls.__name__}", (cls,), {
+        method_name: func
+    })
+    obj.__class__ = new_cls