openlit 1.27.1__py3-none-any.whl → 1.28.0__py3-none-any.whl

openlit/__init__.py

@@ -46,7 +46,7 @@ from openlit.instrumentation.pinecone import PineconeInstrumentor
 from openlit.instrumentation.qdrant import QdrantInstrumentor
 from openlit.instrumentation.milvus import MilvusInstrumentor
 from openlit.instrumentation.transformers import TransformersInstrumentor
-from openlit.instrumentation.gpu import NvidiaGPUInstrumentor
+from openlit.instrumentation.gpu import GPUInstrumentor
 import openlit.guard
 import openlit.evals
 
@@ -313,7 +313,7 @@ def init(environment="default", application_name="default", tracer=None, otlp_en
             disabled_instrumentors, module_name_map)
 
         if not disable_metrics and collect_gpu_stats:
-            NvidiaGPUInstrumentor().instrument(
+            GPUInstrumentor().instrument(
                 environment=config.environment,
                 application_name=config.application_name,
             )

openlit/instrumentation/gpu/__init__.py

@@ -1,132 +1,208 @@
-# pylint: disable=useless-return, bad-staticmethod-argument, duplicate-code, import-outside-toplevel, broad-exception-caught, unused-argument
+# pylint: disable=useless-return, bad-staticmethod-argument, duplicate-code, import-outside-toplevel, broad-exception-caught, unused-argument, import-error, too-many-return-statements, superfluous-parens
 """Initializer of Auto Instrumentation of GPU Metrics"""
 
 from typing import Collection, Iterable
 import logging
 from functools import partial
-
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.sdk.resources import TELEMETRY_SDK_NAME
 from opentelemetry.metrics import get_meter, CallbackOptions, Observation
-
 from openlit.semcov import SemanticConvetion
 
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
 
-class NvidiaGPUInstrumentor(BaseInstrumentor):
+class GPUInstrumentor(BaseInstrumentor):
     """
-    An instrumentor for collecting NVIDIA GPU metrics.
+    An instrumentor for collecting GPU metrics.
     """
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return []
 
     def _instrument(self, **kwargs):
-
         application_name = kwargs.get("application_name", "default")
         environment = kwargs.get("environment", "default")
-
+        # pylint: disable=attribute-defined-outside-init
+        self.gpu_type = self._get_gpu_type()
         meter = get_meter(
             __name__,
             "0.1.0",
             schema_url="https://opentelemetry.io/schemas/1.11.0",
         )
 
-        def check_and_record(value):
-            return value if value is not None else 0
-
-        meter.create_observable_gauge(
-            name=SemanticConvetion.GPU_UTILIZATION,
-            callbacks=[partial(self._collect_metric, environment,
-                               application_name, check_and_record, "utilization")],
-            description="GPU Utilization",
-        )
-        meter.create_observable_gauge(
-            name=SemanticConvetion.GPU_UTILIZATION_ENC,
-            callbacks=[partial(self._collect_metric, environment,
-                               application_name, check_and_record, "utilization_enc")],
-            description="GPU Encoder Utilization",
-        )
-        meter.create_observable_gauge(
-            name=SemanticConvetion.GPU_UTILIZATION_DEC,
-            callbacks=[partial(self._collect_metric, environment,
-                               application_name, check_and_record, "utilization_dec")],
-            description="GPU Decoder Utilization",
-        )
-        meter.create_observable_gauge(
-            name=SemanticConvetion.GPU_TEMPERATURE,
-            callbacks=[partial(self._collect_metric, environment,
-                               application_name, check_and_record, "temperature")],
-            description="GPU Temperature",
-        )
-        meter.create_observable_gauge(
-            name=SemanticConvetion.GPU_FAN_SPEED,
-            callbacks=[partial(self._collect_metric, environment,
-                               application_name, check_and_record, "fan_speed")],
-            description="GPU Fan Speed",
-        )
-        meter.create_observable_gauge(
-            name=SemanticConvetion.GPU_MEMORY_AVAILABLE,
-            callbacks=[partial(self._collect_metric, environment,
-                               application_name, check_and_record, "memory_available")],
-            description="GPU Memory Available",
-        )
-        meter.create_observable_gauge(
-            name=SemanticConvetion.GPU_MEMORY_TOTAL,
-            callbacks=[partial(self._collect_metric, environment,
-                               application_name, check_and_record, "memory_total")],
-            description="GPU Memory Total",
-        )
-        meter.create_observable_gauge(
-            name=SemanticConvetion.GPU_MEMORY_USED,
-            callbacks=[partial(self._collect_metric, environment,
-                               application_name, check_and_record, "memory_used")],
-            description="GPU Memory Used",
-        )
-        meter.create_observable_gauge(
-            name=SemanticConvetion.GPU_MEMORY_FREE,
-            callbacks=[partial(self._collect_metric, environment,
-                               application_name, check_and_record, "memory_free")],
-            description="GPU Memory Free",
-        )
-        meter.create_observable_gauge(
-            name=SemanticConvetion.GPU_POWER_DRAW,
-            callbacks=[partial(self._collect_metric, environment,
-                               application_name, check_and_record, "power_draw")],
-            description="GPU Power Draw",
-        )
-        meter.create_observable_gauge(
-            name=SemanticConvetion.GPU_POWER_LIMIT,
-            callbacks=[partial(self._collect_metric, environment,
-                               application_name, check_and_record, "power_limit")],
-            description="GPU Power Limit",
-        )
+        if not self.gpu_type:
+            logger.error(
+                "OpenLIT GPU Instrumentation Error: No supported GPUs found."
+                "If this is a non-GPU host, set `collect_gpu_stats=False` to disable GPU stats."
+            )
+            return
+
+        metric_names = [
+            ("GPU_UTILIZATION", "utilization"),
+            ("GPU_UTILIZATION_ENC", "utilization_enc"),
+            ("GPU_UTILIZATION_DEC", "utilization_dec"),
+            ("GPU_TEMPERATURE", "temperature"),
+            ("GPU_FAN_SPEED", "fan_speed"),
+            ("GPU_MEMORY_AVAILABLE", "memory_available"),
+            ("GPU_MEMORY_TOTAL", "memory_total"),
+            ("GPU_MEMORY_USED", "memory_used"),
+            ("GPU_MEMORY_FREE", "memory_free"),
+            ("GPU_POWER_DRAW", "power_draw"),
+            ("GPU_POWER_LIMIT", "power_limit"),
+        ]
+
+        for semantic_name, internal_name in metric_names:
+            meter.create_observable_gauge(
+                name=getattr(SemanticConvetion, semantic_name),
+                callbacks=[partial(self._collect_metric,
+                                   environment, application_name, internal_name)],
+                description=f"GPU {internal_name.replace('_', ' ').title()}",
+            )
 
     def _uninstrument(self, **kwargs):
         # Proper uninstrumentation logic to revert patched methods
         pass
 
+    def _get_gpu_type(self) -> str:
+        try:
+            import pynvml
+            pynvml.nvmlInit()
+            return "nvidia"
+        except Exception:
+            try:
+                import amdsmi
+                amdsmi.amdsmi_init()
+                return "amd"
+            except Exception:
+                return None
+
+
     def _collect_metric(self, environment, application_name,
-                        check_and_record, metric_name,
+                        metric_name,
                         options: CallbackOptions) -> Iterable[Observation]:
+        # pylint: disable=no-else-return
+        if self.gpu_type == "nvidia":
+            return self._collect_nvidia_metrics(environment, application_name, metric_name, options)
+        elif self.gpu_type == "amd":
+            return self._collect_amd_metrics(environment, application_name, metric_name, options)
+        return []
 
-        import gpustat
-
+    def _collect_nvidia_metrics(self, environment, application_name,
+                        metric_name,
+                        options: CallbackOptions) -> Iterable[Observation]:
         try:
-            gpu_stats = gpustat.GPUStatCollection.new_query()
+            import pynvml
+            gpu_count = pynvml.nvmlDeviceGetCount()
+            mega_bytes = 1024 * 1024
+            gpu_index = 0
+            for gpu_index in range(gpu_count):
+                handle = pynvml.nvmlDeviceGetHandleByIndex(gpu_index)
+
+                def get_metric_value(handle, metric_name):
+                    try:
+                        # pylint: disable=no-else-return
+                        if metric_name == "temperature":
+                            return pynvml.nvmlDeviceGetTemperature(handle,
+                                                                   pynvml.NVML_TEMPERATURE_GPU)
+                        elif metric_name == "utilization":
+                            return pynvml.nvmlDeviceGetUtilizationRates(handle).gpu
+                        elif metric_name == "utilization_enc":
+                            return pynvml.nvmlDeviceGetEncoderUtilization(handle)[0]
+                        elif metric_name == "utilization_dec":
+                            return pynvml.nvmlDeviceGetDecoderUtilization(handle)[0]
+                        elif metric_name == "fan_speed":
+                            return 0
+                        elif metric_name == "memory_available":
+                            memory_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
+                            return (memory_info.free // mega_bytes)  # Assuming reserved memory is 0
+                        elif metric_name == "memory_total":
+                            return (pynvml.nvmlDeviceGetMemoryInfo(handle).total // mega_bytes)
+                        elif metric_name == "memory_used":
+                            return (pynvml.nvmlDeviceGetMemoryInfo(handle).used // mega_bytes)
+                        elif metric_name == "memory_free":
+                            return (pynvml.nvmlDeviceGetMemoryInfo(handle).free // mega_bytes)
+                        elif metric_name == "power_draw":
+                            return (pynvml.nvmlDeviceGetPowerUsage(handle) // 1000.0)
+                        elif metric_name == "power_limit":
+                            return (pynvml.nvmlDeviceGetEnforcedPowerLimit(handle) // 1000.0)
+                    except Exception as e:
+                        # pylint: disable=cell-var-from-loop
+                        logger.error("Error collecting metric %s for GPU %d: %s", metric_name,
+                                                                                  gpu_index, e)
+                    return 0
 
-            for gpu in gpu_stats.gpus:
                 attributes = {
                     TELEMETRY_SDK_NAME: "openlit",
                     SemanticConvetion.GEN_AI_APPLICATION_NAME: application_name,
                     SemanticConvetion.GEN_AI_ENVIRONMENT: environment,
-                    SemanticConvetion.GPU_INDEX: gpu.index,
-                    SemanticConvetion.GPU_UUID: gpu.uuid,
-                    SemanticConvetion.GPU_NAME: gpu.name,
+                    SemanticConvetion.GPU_INDEX: str(gpu_index),
+                    SemanticConvetion.GPU_UUID: pynvml.nvmlDeviceGetUUID(handle).decode('utf-8'),
+                    SemanticConvetion.GPU_NAME: pynvml.nvmlDeviceGetName(handle).decode('utf-8')
                 }
-
-                yield Observation(check_and_record(getattr(gpu, metric_name, 0)), attributes)
+                yield Observation(get_metric_value(handle, metric_name), attributes)
 
         except Exception as e:
             logger.error("Error in GPU metrics collection: %s", e)
+
+    def _collect_amd_metrics(self, environment, application_name,
+                             metric_name,
+                             options: CallbackOptions) -> Iterable[Observation]:
+        try:
+            import amdsmi
+            # Get the number of AMD GPUs
+            devices = amdsmi.amdsmi_get_processor_handles()
+            mega_bytes = 1024 * 1024
+            for device_handle in devices:
+
+                def get_metric_value(device_handle, metric_name):
+                    try:
+                        # pylint: disable=no-else-return
+                        if metric_name == "temperature":
+                            # pylint: disable=line-too-long
+                            return amdsmi.amdsmi_get_temp_metric(device_handle,
+                                                                 amdsmi.AmdSmiTemperatureType.EDGE,
+                                                                 amdsmi.AmdSmiTemperatureMetric.CURRENT)
+                        elif metric_name == "utilization":
+                            # pylint: disable=line-too-long
+                            return amdsmi.amdsmi_get_utilization_count(device_handle,
+                                                                       amdsmi.AmdSmiUtilizationCounterType.COARSE_GRAIN_GFX_ACTIVITY)
+                        elif metric_name in ["utilization_enc", "utilization_dec"]:
+                            return 0  # Placeholder if unsupported
+                        elif metric_name == "fan_speed":
+                            return amdsmi.amdsmi_get_gpu_fan_speed(device_handle, 0)
+                        elif metric_name == "memory_available":
+                            return (amdsmi.amdsmi_get_gpu_memory_total(device_handle) // mega_bytes)
+                        elif metric_name == "memory_total":
+                            return (amdsmi.amdsmi_get_gpu_memory_total(device_handle) // mega_bytes)
+                        elif metric_name == "memory_used":
+                            return (amdsmi.amdsmi_get_gpu_memory_usage(device_handle) // mega_bytes)
+                        elif metric_name == "memory_free":
+                            total_mem = (amdsmi.amdsmi_get_gpu_memory_total(device_handle) // mega_bytes)
+                            used_mem = (amdsmi.amdsmi_get_gpu_memory_usage(device_handle) // mega_bytes)
+                            return (total_mem - used_mem)
+                        elif metric_name == "power_draw":
+                            # pylint: disable=line-too-long
+                            return (amdsmi.amdsmi_get_power_info(device_handle)['average_socket_power'] // 1000.0)
+                        elif metric_name == "power_limit":
+                            # pylint: disable=line-too-long
+                            return (amdsmi.amdsmi_get_power_info(device_handle)['power_limit'] // 1000.0)
+                    except Exception as e:
+                        logger.error("Error collecting metric %s for AMD GPU %d: %s", metric_name,
+                                      amdsmi.amdsmi_get_xgmi_info(device_handle)['index'], e)
+                    return 0
+
+                attributes = {
+                    TELEMETRY_SDK_NAME: "openlit",
+                    SemanticConvetion.GEN_AI_APPLICATION_NAME: application_name,
+                    SemanticConvetion.GEN_AI_ENVIRONMENT: environment,
+                    # pylint: disable=line-too-long
+                    SemanticConvetion.GPU_INDEX: amdsmi.amdsmi_get_xgmi_info(device_handle)['index'],
+                    # pylint: disable=line-too-long
+                    SemanticConvetion.GPU_UUID: amdsmi.amdsmi_get_gpu_asic_info(device_handle)['market_name'],
+                    SemanticConvetion.GPU_NAME: amdsmi.amdsmi_get_device_name(device_handle)
+                }
+                yield Observation(get_metric_value(device_handle, metric_name), attributes)
+
+        except Exception as e:
+            logger.error("Error in AMD GPU metrics collection: %s", e)

{openlit-1.27.1.dist-info → openlit-1.28.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openlit
-Version: 1.27.1
+Version: 1.28.0
 Summary: OpenTelemetry-native Auto instrumentation library for monitoring LLM Applications and GPUs, facilitating the integration of observability into your GenAI-driven projects
 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,gpu
@@ -16,7 +16,6 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: anthropic (>=0.21.0,<0.22.0)
 Requires-Dist: boto3 (>=1.34.0,<2.0.0)
 Requires-Dist: botocore (>=1.34.0,<2.0.0)
-Requires-Dist: gpustat (>=1.1.1,<2.0.0)
 Requires-Dist: openai (>=1.1.1,<2.0.0)
 Requires-Dist: opentelemetry-api (>=1.27.0,<2.0.0)
 Requires-Dist: opentelemetry-exporter-otlp (>=1.27.0,<2.0.0)
@@ -26,6 +25,7 @@ Requires-Dist: pydantic (>=2.0.0,<3.0.0)
 Requires-Dist: requests (>=2.26.0,<3.0.0)
 Requires-Dist: schedule (>=1.2.2,<2.0.0)
 Requires-Dist: tiktoken (>=0.7.0,<0.8.0)
+Requires-Dist: xmltodict (>=0.13.0,<0.14.0)
 Project-URL: Repository, https://github.com/openlit/openlit/tree/main/openlit/python
 Description-Content-Type: text/markdown
 
@@ -65,8 +65,8 @@ This project proudly follows and maintains the [Semantic Conventions](https://gi
 
 | LLMs                                                                      | Vector DBs                                   | Frameworks                                   | GPUs          |
 |--------------------------------------------------------------------------|----------------------------------------------|----------------------------------------------|---------------|
-| [✅ OpenAI](https://docs.openlit.io/latest/integrations/openai)                      | [✅ ChromaDB](https://docs.openlit.io/latest/integrations/chromadb)       | [✅ Langchain](https://docs.openlit.io/latest/integrations/langchain)     | [✅ NVIDIA GPUs](https://docs.openlit.io/latest/integrations/nvidia-gpu) |
-| [✅ Ollama](https://docs.openlit.io/latest/integrations/ollama)                      | [✅ Pinecone](https://docs.openlit.io/latest/integrations/pinecone)       | [✅ LiteLLM](https://docs.openlit.io/latest/integrations/litellm)         |               |
+| [✅ OpenAI](https://docs.openlit.io/latest/integrations/openai)                      | [✅ ChromaDB](https://docs.openlit.io/latest/integrations/chromadb)       | [✅ Langchain](https://docs.openlit.io/latest/integrations/langchain)     | [✅ NVIDIA](https://docs.openlit.io/latest/integrations/nvidia-gpu) |
+| [✅ Ollama](https://docs.openlit.io/latest/integrations/ollama)                      | [✅ Pinecone](https://docs.openlit.io/latest/integrations/pinecone)       | [✅ LiteLLM](https://docs.openlit.io/latest/integrations/litellm)         | [✅ AMD](#)                   |
 | [✅ Anthropic](https://docs.openlit.io/latest/integrations/anthropic)                | [✅ Qdrant](https://docs.openlit.io/latest/integrations/qdrant)           | [✅ LlamaIndex](https://docs.openlit.io/latest/integrations/llama-index)  |               |
 | [✅ GPT4All](https://docs.openlit.io/latest/integrations/gpt4all)                    | [✅ Milvus](https://docs.openlit.io/latest/integrations/milvus)           | [✅ Haystack](https://docs.openlit.io/latest/integrations/haystack)       |               |
 | [✅ Cohere](https://docs.openlit.io/latest/integrations/cohere)                      |                                          | [✅ EmbedChain](https://docs.openlit.io/latest/integrations/embedchain)   |               |                                       

{openlit-1.27.1.dist-info → openlit-1.28.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 openlit/__helpers.py,sha256=H-8uJKs_CP9Y2HL4lz5n0AgN60wwZ675hlWHMDO143A,5936
-openlit/__init__.py,sha256=dboS_trymEQ2zubonTuMSRqiFIhy0A9tK0PAktEHc08,19329
+openlit/__init__.py,sha256=y0YPACLr3feXqIQJDcHw6Yc1c43mmc8AgQmUrOTG59U,19317
 openlit/evals/__init__.py,sha256=nJe99nuLo1b5rf7pt9U9BCdSDedzbVi2Fj96cgl7msM,380
 openlit/evals/all.py,sha256=oWrue3PotE-rB5WePG3MRYSA-ro6WivkclSHjYlAqGs,7154
 openlit/evals/bias_detection.py,sha256=mCdsfK7x1vX7S3psC3g641IMlZ-7df3h-V6eiICj5N8,8154
@@ -34,7 +34,7 @@ openlit/instrumentation/google_ai_studio/async_google_ai_studio.py,sha256=20MHsp
 openlit/instrumentation/google_ai_studio/google_ai_studio.py,sha256=vIJjzl5Fkgsf3vfaqmxhtSFvOpXK-wGC-JFhEXGP50M,13636
 openlit/instrumentation/gpt4all/__init__.py,sha256=-59CP2B3-HGZJ_vC-fI9Dt-0BuQXRhSCWCjnaGeU15Q,1802
 openlit/instrumentation/gpt4all/gpt4all.py,sha256=dbxqZeuTrv_y6wyDOIEmC8-Dc4iCGgLpj3l5JiodLMI,18787
-openlit/instrumentation/gpu/__init__.py,sha256=Dj2MLar0DB20-t6W3pfR-3jfR_mwg4SYwhzIrH_n9sU,5596
+openlit/instrumentation/gpu/__init__.py,sha256=wahEF66rCRVT8XafJkif6Yac8JcIMTMMm9fN1X2lwhI,10882
 openlit/instrumentation/groq/__init__.py,sha256=uW_0G6HSanQyK2dIXYhzR604pDiyPQfybzc37DsfSew,1911
 openlit/instrumentation/groq/async_groq.py,sha256=myob-d9V66YiNmkFd9rtmMaXjlLiSMVHi_US16L-rZw,20011
 openlit/instrumentation/groq/groq.py,sha256=m4gFPbYzjUUIgjXZ0Alu2Zy1HcO5takCFA2XFnkcGVo,19975
@@ -71,7 +71,7 @@ openlit/instrumentation/vllm/vllm.py,sha256=lDzM7F5pgxvh8nKL0dcKB4TD0Mc9wXOWeXOs
 openlit/otel/metrics.py,sha256=FYAk4eBAmNtFKUIp4hbRbpdq4LME6MapyCQOIeuhmEg,4337
 openlit/otel/tracing.py,sha256=2kSj7n7uXSkRegcGFDC8IbnDOxqWTA8dGODs__Yn_yA,3719
 openlit/semcov/__init__.py,sha256=xPsw1aPonDSGYVuga-ZdoGt4yyA16wNFi5AEc7_xIrQ,8114
-openlit-1.27.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openlit-1.27.1.dist-info/METADATA,sha256=A5el-uDDg_yZPRFEuYiNrpl1vTJX7tT2ETY6rio1GEA,20790
-openlit-1.27.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-openlit-1.27.1.dist-info/RECORD,,
+openlit-1.28.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openlit-1.28.0.dist-info/METADATA,sha256=egvLD1EGcwE-1eRjIErX_kIqhRYTXRO6hm8EtwYOR0M,20806
+openlit-1.28.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+openlit-1.28.0.dist-info/RECORD,,