fix: add test cases

opentelemetry-jaeger/src/exporter/mod.rs

@@ -638,11 +638,11 @@ fn build_span_tags(
         }
         tags.push(
             Key::new(OTEL_STATUS_CODE)
-                .string::<String>(status_code.into())
+                .string::<&'static str>(status_code.as_str())
                 .into(),
         );
         // set status message if there is one
-        if status_message.len() > 0 {
+        if !status_message.is_empty() {
             if !user_overrides.status_message {
                 tags.push(
                     Key::new(STATUS_MESSAGE)
@@ -728,7 +728,7 @@ impl ExportError for Error {
 
 #[cfg(test)]
 #[cfg(feature = "collector_client")]
-mod tests {
+mod collector_client_tests {
     use crate::exporter::thrift::jaeger::Batch;
     use crate::new_pipeline;
     use opentelemetry::trace::TraceError;
@@ -775,3 +775,83 @@ mod tests {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::exporter::thrift::jaeger::Tag;
+    use crate::exporter::{build_span_tags, OTEL_STATUS_CODE, OTEL_STATUS_DESCRIPTION};
+    use opentelemetry::sdk::trace::EvictedHashMap;
+    use opentelemetry::trace::{SpanKind, StatusCode};
+
+    fn assert_tag_contains(tags: Vec<Tag>, key: &'static str, expect_val: &'static str) {
+        assert_eq!(
+            tags.into_iter()
+                .filter(|tag| tag.key.as_str() == key
+                    && tag.v_str.as_deref().unwrap_or("") == expect_val)
+                .count(),
+            1,
+            "Expect a tag {} with value {} but found nothing",
+            key,
+            expect_val
+        );
+    }
+
+    fn assert_tag_not_contains(tags: Vec<Tag>, key: &'static str) {
+        assert_eq!(
+            tags.into_iter()
+                .filter(|tag| tag.key.as_str() == key)
+                .count(),
+            0,
+            "Not expect tag {}, but found something",
+            key
+        );
+    }
+
+    fn get_error_tag_test_data() -> Vec<(
+        StatusCode,
+        String,
+        Option<&'static str>,
+        Option<&'static str>,
+    )> {
+        // StatusCode, error message, OTEL_STATUS_CODE tag value, OTEL_STATUS_DESCRIPTION tag value
+        vec![
+            (StatusCode::Error, "".into(), Some("ERROR"), None),
+            (StatusCode::Unset, "".into(), None, None),
+            // When status is ok, no description should be in span data. This should be ensured by Otel API
+            (StatusCode::Ok, "".into(), Some("OK"), None),
+            (
+                StatusCode::Error,
+                "have message".into(),
+                Some("ERROR"),
+                Some("have message"),
+            ),
+            (StatusCode::Unset, "have message".into(), None, None),
+        ]
+    }
+
+    #[test]
+    fn test_set_status() -> Result<(), Box<dyn std::error::Error>> {
+        for (status_code, error_msg, status_tag_val, msg_tag_val) in get_error_tag_test_data() {
+            let tags = build_span_tags(
+                EvictedHashMap::new(20, 20),
+                None,
+                status_code,
+                error_msg,
+                SpanKind::Client,
+            )
+            .unwrap_or_default();
+            if let Some(val) = status_tag_val {
+                assert_tag_contains(tags.clone(), OTEL_STATUS_CODE, val);
+            } else {
+                assert_tag_not_contains(tags.clone(), OTEL_STATUS_CODE);
+            }
+
+            if let Some(val) = msg_tag_val {
+                assert_tag_contains(tags.clone(), OTEL_STATUS_DESCRIPTION, val);
+            } else {
+                assert_tag_not_contains(tags.clone(), OTEL_STATUS_DESCRIPTION);
+            }
+        }
+        Ok(())
+    }
+}

opentelemetry-zipkin/src/exporter/model/mod.rs

@@ -57,6 +57,7 @@ fn into_zipkin_span_kind(kind: SpanKind) -> Option<span::Kind> {
 /// Converts a `trace::SpanData` to a `span::SpanData` for a given `ExporterConfig`, which can then
 /// be ingested into a Zipkin collector.
 pub(crate) fn into_zipkin_span(local_endpoint: Endpoint, span_data: trace::SpanData) -> span::Span {
+    // see tests in create/exporter/model/span.rs
     let mut user_defined_span_kind = false;
     let mut tags = map_from_kvs(
         span_data
@@ -88,9 +89,8 @@ pub(crate) fn into_zipkin_span(local_endpoint: Endpoint, span_data: trace::SpanD
                 .iter()
                 .filter_map(|(key, val)| val.map(|val| KeyValue::new(*key, val))),
             )
-            .filter(|kv| kv.key.as_str() == "error" && kv.value.as_str() == "false"),
+            .filter(|kv| kv.key.as_str() != "error"),
     );
-
     if let Some(status_code) = from_statuscode_to_str(span_data.status_code) {
         if status_code == "ERROR" {
             tags.insert(OTEL_ERROR_DESCRIPTION.into(), span_data.status_message);

opentelemetry-zipkin/src/exporter/model/span.rs

@@ -58,8 +58,14 @@ mod tests {
     use crate::exporter::model::annotation::Annotation;
     use crate::exporter::model::endpoint::Endpoint;
     use crate::exporter::model::span::{Kind, Span};
+    use crate::exporter::model::{into_zipkin_span, OTEL_ERROR_DESCRIPTION, OTEL_STATUS_CODE};
+    use opentelemetry::sdk::export::trace::SpanData;
+    use opentelemetry::sdk::trace::{EvictedHashMap, EvictedQueue};
+    use opentelemetry::trace::{SpanContext, SpanId, SpanKind, StatusCode, TraceId};
     use std::collections::HashMap;
     use std::net::Ipv4Addr;
+    use std::sync::Arc;
+    use std::time::SystemTime;
 
     #[test]
     fn test_empty() {
@@ -112,4 +118,77 @@ mod tests {
         let result = serde_json::to_string(&span).unwrap();
         assert_eq!(result, desired.to_owned());
     }
+
+    fn assert_tag_contains(
+        tags: &HashMap<String, String>,
+        key: &'static str,
+        expected_val: Option<&'static str>,
+    ) {
+        let val = tags.get::<String>(&key.to_string()).map(|s| s.as_str());
+        assert_eq!(
+            val,
+            expected_val,
+            "expect value of key {} to be {}, but got {}",
+            key,
+            expected_val.unwrap_or("none"),
+            val.unwrap_or("none")
+        );
+    }
+
+    fn get_set_status_test_data() -> Vec<(
+        StatusCode,
+        String,
+        Option<&'static str>,
+        Option<&'static str>,
+    )> {
+        // status code, status message, whether OTEL_STATUS_CODE is set, whether OTEL_ERROR_DESCRIPTION is set, whether error tag is set
+        vec![
+            (StatusCode::Ok, "".into(), Some("OK"), None),
+            (StatusCode::Error, "".into(), Some("ERROR"), Some("")),
+            (
+                StatusCode::Error,
+                "error msg".into(),
+                Some("ERROR"),
+                Some("error msg"),
+            ),
+            (StatusCode::Unset, "whatever".into(), None, None),
+        ]
+    }
+
+    #[test]
+    fn test_set_status() -> Result<(), Box<dyn std::error::Error>> {
+        for (status_code, status_msg, status_tag_val, status_msg_tag_val) in
+            get_set_status_test_data()
+        {
+            let span_data = SpanData {
+                span_context: SpanContext::new(
+                    TraceId::from_u128(1),
+                    SpanId::from_u64(1),
+                    0,
+                    false,
+                    Default::default(),
+                ),
+                parent_span_id: SpanId::from_u64(1),
+                span_kind: SpanKind::Client,
+                name: "".to_string(),
+                start_time: SystemTime::now(),
+                end_time: SystemTime::now(),
+                attributes: EvictedHashMap::new(20, 20),
+                message_events: EvictedQueue::new(20),
+                links: EvictedQueue::new(20),
+                status_code,
+                status_message: status_msg,
+                resource: Arc::new(Default::default()),
+                instrumentation_lib: Default::default(),
+            };
+            let local_endpoint = Endpoint::new("test".into(), None);
+            let span = into_zipkin_span(local_endpoint, span_data);
+            if let Some(tags) = span.tags.as_ref() {
+                assert_tag_contains(tags, OTEL_STATUS_CODE, status_tag_val);
+                assert_tag_contains(tags, OTEL_ERROR_DESCRIPTION, status_msg_tag_val);
+            };
+        }
+
+        Ok(())
+    }
 }

opentelemetry/src/api/trace/span.rs

@@ -251,12 +251,13 @@ pub enum StatusCode {
     Error = 2,
 }
 
-impl Into<String> for StatusCode {
-    fn into(self) -> String {
+impl StatusCode {
+    /// Return a static str that represent the status code
+    pub fn as_str(&self) -> &'static str {
         match self {
-            StatusCode::Unset => "".to_string(),
-            StatusCode::Ok => "OK".to_string(),
-            StatusCode::Error => "Error".to_string(),
+            StatusCode::Unset => "",
+            StatusCode::Ok => "OK",
+            StatusCode::Error => "ERROR",
         }
     }
 }

opentelemetry/src/sdk/trace/span.rs

@@ -355,14 +355,36 @@ mod tests {
 
     #[test]
     fn set_status() {
-        let span = create_span();
-        let status = StatusCode::Ok;
-        let message = "OK".to_string();
-        span.set_status(status.clone(), message.clone());
-        span.with_data(|data| {
-            assert_eq!(data.status_code, status);
-            assert_eq!(data.status_message, message);
-        });
+        {
+            let span = create_span();
+            let status = StatusCode::Ok;
+            let message = "OK".to_string();
+            span.set_status(status, message);
+            span.with_data(|data| {
+                assert_eq!(data.status_code, status);
+                assert_eq!(data.status_message, "");
+            });
+        }
+        {
+            let span = create_span();
+            let status = StatusCode::Unset;
+            let message = "OK".to_string();
+            span.set_status(status, message);
+            span.with_data(|data| {
+                assert_eq!(data.status_code, status);
+                assert_eq!(data.status_message, "");
+            });
+        }
+        {
+            let span = create_span();
+            let status = StatusCode::Error;
+            let message = "Error".to_string();
+            span.set_status(status, message);
+            span.with_data(|data| {
+                assert_eq!(data.status_code, status);
+                assert_eq!(data.status_message, "Error");
+            });
+        }
     }
 
     #[test]