fix(tracing): add vendor reporting for OTEL tracing (#64)

Author: doronkopit5

src/config/validation.rs

@@ -52,15 +52,15 @@ pub fn validate_gateway_config(config: &GatewayConfig) -> Result<(), Vec<String>
 #[cfg(test)]
 mod tests {
     use super::*; // To import validate_gateway_config
-    use crate::types::{ModelConfig, Pipeline, PipelineType, PluginConfig, Provider}; // For test data
+    use crate::types::{ModelConfig, Pipeline, PipelineType, PluginConfig, Provider, ProviderType}; // For test data
 
     #[test]
     fn test_valid_config() {
         let config = GatewayConfig {
             general: None,
             providers: vec![Provider {
                 key: "p1".to_string(),
-                r#type: "openai".to_string(),
+                r#type: ProviderType::OpenAI,
                 api_key: "key1".to_string(),
                 params: Default::default(),
             }],
@@ -87,7 +87,7 @@ mod tests {
             general: None,
             providers: vec![Provider {
                 key: "p1".to_string(),
-                r#type: "openai".to_string(),
+                r#type: ProviderType::OpenAI,
                 api_key: "key1".to_string(),
                 params: Default::default(),
             }],
@@ -112,7 +112,7 @@ mod tests {
             general: None,
             providers: vec![Provider {
                 key: "p1".to_string(),
-                r#type: "openai".to_string(),
+                r#type: ProviderType::OpenAI,
                 api_key: "key1".to_string(),
                 params: Default::default(),
             }],

src/management/dto.rs

@@ -3,6 +3,8 @@ use serde::{Deserialize, Serialize};
 use sqlx::types::Uuid;
 use utoipa::ToSchema;
 
+pub use crate::types::ProviderType;
+
 /// Represents different ways to store and retrieve secrets
 #[derive(Serialize, Deserialize, Debug, ToSchema, Clone, PartialEq, Eq)]
 #[serde(tag = "type")]
@@ -50,49 +52,6 @@ impl SecretObject {
     }
 }
 
-/// Enum representing the type of LLM provider.
-#[derive(Serialize, Deserialize, Debug, ToSchema, Clone, Copy, PartialEq, Eq, Hash)]
-#[serde(rename_all = "snake_case")]
-pub enum ProviderType {
-    #[serde(rename = "azure")]
-    Azure,
-    #[serde(rename = "openai")]
-    OpenAI,
-    #[serde(rename = "anthropic")]
-    Anthropic,
-    #[serde(rename = "bedrock")]
-    Bedrock,
-    #[serde(rename = "vertexai")]
-    VertexAI,
-}
-
-impl std::fmt::Display for ProviderType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ProviderType::Azure => write!(f, "azure"),
-            ProviderType::OpenAI => write!(f, "openai"),
-            ProviderType::Anthropic => write!(f, "anthropic"),
-            ProviderType::Bedrock => write!(f, "bedrock"),
-            ProviderType::VertexAI => write!(f, "vertexai"),
-        }
-    }
-}
-
-impl std::str::FromStr for ProviderType {
-    type Err = String; // Or a custom error type
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
-            "azure" => Ok(ProviderType::Azure),
-            "openai" => Ok(ProviderType::OpenAI),
-            "anthropic" => Ok(ProviderType::Anthropic),
-            "bedrock" => Ok(ProviderType::Bedrock),
-            "vertexai" => Ok(ProviderType::VertexAI),
-            _ => Err(format!("Unknown provider type: {s}")),
-        }
-    }
-}
-
 /// Configuration specific to OpenAI providers.
 #[derive(Serialize, Deserialize, Debug, ToSchema, Clone, PartialEq, Eq)]
 pub struct OpenAIProviderConfig {

src/management/services/config_provider_service.rs

@@ -184,7 +184,7 @@ impl ConfigProviderService {
 
         Ok(Provider {
             key: dto.name,
-            r#type: dto.provider_type.to_string(),
+            r#type: dto.provider_type,
             api_key: api_key_from_dto.unwrap_or_default(),
             params,
         })

src/pipelines/otel.rs

@@ -172,6 +172,11 @@ impl OtelTracer {
     pub fn log_error(&mut self, description: String) {
         self.span.set_status(Status::error(description));
     }
+
+    pub fn set_vendor(&mut self, vendor: &str) {
+        self.span
+            .set_attribute(KeyValue::new(GEN_AI_SYSTEM, vendor.to_string()));
+    }
 }
 
 impl RecordSpan for ChatCompletionRequest {
@@ -385,3 +390,38 @@ impl RecordSpan for EmbeddingUsage {
         ));
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::providers::provider::get_vendor_name;
+    use crate::types::ProviderType;
+
+    #[test]
+    fn test_get_vendor_name_mappings() {
+        // Test all provider type mappings to standardized vendor names
+        assert_eq!(get_vendor_name(&ProviderType::OpenAI), "openai");
+        assert_eq!(get_vendor_name(&ProviderType::Azure), "Azure");
+        assert_eq!(get_vendor_name(&ProviderType::Anthropic), "Anthropic");
+        assert_eq!(get_vendor_name(&ProviderType::Bedrock), "AWS");
+        assert_eq!(get_vendor_name(&ProviderType::VertexAI), "Google");
+    }
+
+    #[test]
+    fn test_set_vendor_method_exists() {
+        // Test that set_vendor method compiles and can be called
+        // This ensures the method signature is correct
+        let mut tracer = OtelTracer {
+            span: opentelemetry::global::tracer("test").start("test"),
+            accumulated_completion: None,
+        };
+
+        // Call set_vendor with different vendor names - this tests the method exists and accepts strings
+        tracer.set_vendor("OpenAI");
+        tracer.set_vendor("Anthropic");
+        tracer.set_vendor("Azure");
+
+        // If this test passes, it means set_vendor() is working without panicking
+        assert!(true);
+    }
+}