monocle-apptrace 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

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/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/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/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/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/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/instrumentation/common/constants.py

@@ -14,10 +14,10 @@ GITHUB_CODESPACE_IDENTIFIER_ENV_NAME = "GITHUB_REPOSITORY"
 # Azure naming reference can be found here
 # https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/ready/azure-best-practices/resource-abbreviations
 # https://docs.aws.amazon.com/resource-explorer/latest/userguide/supported-resource-types.html#services-lookoutmetrics
-AZURE_FUNCTION_NAME = "azure.func"
-AZURE_APP_SERVICE_NAME = "azure.asp"
-AZURE_ML_SERVICE_NAME = "azure.mlw"
-AWS_LAMBDA_SERVICE_NAME = "aws.lambda"
+AZURE_FUNCTION_NAME = "azure_func"
+AZURE_APP_SERVICE_NAME = "azure_webapp"
+AZURE_ML_SERVICE_NAME = "azure_ml"
+AWS_LAMBDA_SERVICE_NAME = "aws_lambda"
 GITHUB_CODESPACE_SERVICE_NAME = "github_codespace"
 
 # Env variables to identify infra service type
@@ -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/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/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:
@@ -41,18 +42,28 @@ class SpanHandler:
     def skip_span(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
         return False
 
-    def skip_processor(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
-        return False
+    def skip_processor(self, to_wrap, wrapped, instance, span, args, kwargs) -> list[str]:
+        return []
+    
+    def set_span_type(self, to_wrap, wrapped, instance, output_processor, span:Span, args, kwargs) -> str:
+        span_type:str = None
+        if 'type' in output_processor:
+            span_type = output_processor['type']
+            span.set_attribute("span.type", span_type)
+        else:
+            logger.warning("type of span not found or incorrect written in entity json")
+        return span_type
 
     def pre_task_processing(self, to_wrap, wrapped, instance, args,kwargs, span):
         if "pipeline" in to_wrap['package']:
             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,34 +73,37 @@ 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)
         if workflow_name:
             span.set_attribute("workflow.name", workflow_name)
+        span.set_attribute("span.type", "generic")
 
     def post_task_processing(self, to_wrap, wrapped, instance, args, kwargs, result, span:Span):
-        if span.status.status_code == StatusCode.UNSET:
-            span.set_status(StatusCode.OK)
+        pass
 
-    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, parent_span = None, ex:Exception = None) -> bool:
+        try:
+            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, parent_span, ex)
+            if detected_error_in_attribute or detected_error_in_event:
+                span.set_attribute(MONOCLE_DETECTED_SPAN_ERROR, True)
+        finally:
+            if span.status.status_code == StatusCode.UNSET and ex is None:
+                span.set_status(StatusCode.OK)
 
-    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
-        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):
+        if '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'])
-            else:
-                logger.warning("type of span not found or incorrect written in entity json")
-            if 'attributes' in output_processor:
+            self.set_span_type(to_wrap, wrapped, instance, output_processor, span, args, kwargs)
+            skip_processors:list[str] = self.skip_processor(to_wrap, wrapped, instance, span, args, kwargs) or []
+
+            if 'attributes' in output_processor and 'attributes' not in skip_processors:
                 for processors in output_processor["attributes"]:
                     for processor in processors:
                         attribute = processor.get('attribute')
@@ -104,15 +118,12 @@ 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:
                             logger.debug(f"{' and '.join([key for key in ['attribute', 'accessor'] if not processor.get(key)])} not found or incorrect in entity JSON")
                     span_index += 1
-            else:
-                logger.debug("attributes not found or incorrect written in entity json")
-        else:
-            span.set_attribute("span.type", "generic")
 
         # set scopes as attributes by calling get_scopes()
         # scopes is a Mapping[str:object], iterate directly with .items()
@@ -121,17 +132,23 @@ 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):
-        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):
+    def hydrate_events(self, to_wrap, wrapped, instance, args, kwargs, ret_result, span, parent_span=None, ex:Exception=None) -> bool:
+        detected_error:bool = False
+        if '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}
-            if 'events' in output_processor:
+            skip_processors:list[str] = self.skip_processor(to_wrap, wrapped, instance, span, args, kwargs) or []
+
+            arguments = {"instance": instance, "args": args, "kwargs": kwargs, "result": ret_result, "exception":ex}
+            # Process events if they are defined in the output_processor.
+            # In case of inference.modelapi skip the event processing unless the span has an exception
+            if 'events' in output_processor and ('events' not in skip_processors or ex is not None):
                 events = output_processor['events']
                 for event in events:
                     event_name = event.get("name")
+                    if 'events.'+event_name in skip_processors and ex is None:
+                        continue
                     event_attributes = {}
                     attributes = event.get("attributes", [])
                     for attribute in attributes:
@@ -139,15 +156,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):
@@ -216,7 +243,7 @@ class SpanHandler:
 
     @staticmethod
     @contextmanager
-    def workflow_type(to_wrap=None):
+    def workflow_type(to_wrap=None, span:Span=None):
         token = SpanHandler.attach_workflow_type(to_wrap)
         try:
             yield
@@ -226,6 +253,20 @@ class SpanHandler:
 
 class NonFrameworkSpanHandler(SpanHandler):
 
+    def get_workflow_name_in_progress(self) -> str:
+        return get_value(WORKFLOW_TYPE_KEY)
+
+    def is_framework_span_in_progess(self) -> bool:
+        return self.get_workflow_name_in_progress() in WORKFLOW_TYPE_MAP.values()
+
     # If the language framework is being executed, then skip generating direct openAI attributes and events
-    def skip_processor(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
-        return get_value(WORKFLOW_TYPE_KEY) in WORKFLOW_TYPE_MAP.values()
+    def skip_processor(self, to_wrap, wrapped, instance, span, args, kwargs) -> list[str]:
+        if self.is_framework_span_in_progess():
+            return ["attributes", "events"]
+    
+    def set_span_type(self, to_wrap, wrapped, instance, output_processor, span:Span, args, kwargs) -> str:
+        span_type = super().set_span_type(to_wrap, wrapped, instance, output_processor, span, args, kwargs)
+        if self.is_framework_span_in_progess() and span_type is not None:
+            span_type = span_type+".modelapi"
+            span.set_attribute("span.type", span_type)
+        return span_type