[3.x] - Add baggage to Helidon Span (helidon-io#6692)

* Add baggage to Helidon Span

Author: dalexandrov

dependencies/pom.xml

@@ -133,9 +133,9 @@
         <version.lib.database.messaging>19.3.0.0</version.lib.database.messaging>
         <version.lib.okhttp3>3.14.9</version.lib.okhttp3>
         <version.lib.okio>1.17.5</version.lib.okio>
-        <version.lib.opentelemetry>1.15.0</version.lib.opentelemetry>
-        <version.lib.opentelemetry.semconv>1.15.0-alpha</version.lib.opentelemetry.semconv>
-        <version.lib.opentelemetry.opentracing.shim>1.15.0-alpha</version.lib.opentelemetry.opentracing.shim>
+        <version.lib.opentelemetry>1.22.0</version.lib.opentelemetry>
+        <version.lib.opentelemetry.semconv>1.22.0-alpha</version.lib.opentelemetry.semconv>
+        <version.lib.opentelemetry.opentracing.shim>1.22.0-alpha</version.lib.opentelemetry.opentracing.shim>
         <version.lib.opentracing>0.33.0</version.lib.opentracing>
         <version.lib.opentracing.grpc>0.2.1</version.lib.opentracing.grpc>
         <version.lib.opentracing.tracerresolver>0.1.8</version.lib.opentracing.tracerresolver>

tracing/opentelemetry/src/main/java/io/helidon/tracing/opentelemetry/OpenTelemetrySpan.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2023 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,40 +16,47 @@
 package io.helidon.tracing.opentelemetry;
 
 import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
 
+import io.helidon.common.context.Contexts;
 import io.helidon.tracing.Scope;
+import io.helidon.tracing.Span;
 import io.helidon.tracing.SpanContext;
 
+import io.opentelemetry.api.baggage.Baggage;
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.common.AttributesBuilder;
-import io.opentelemetry.api.trace.Span;
 import io.opentelemetry.api.trace.StatusCode;
 import io.opentelemetry.context.Context;
 
-class OpenTelemetrySpan implements io.helidon.tracing.Span {
-    private final Span delegate;
+class OpenTelemetrySpan implements Span {
+    private final io.opentelemetry.api.trace.Span delegate;
 
-    OpenTelemetrySpan(Span span) {
+    OpenTelemetrySpan(io.opentelemetry.api.trace.Span span) {
         this.delegate = span;
     }
 
     @Override
-    public void tag(String key, String value) {
+    public Span tag(String key, String value) {
         delegate.setAttribute(key, value);
+        return this;
     }
 
     @Override
-    public void tag(String key, Boolean value) {
+    public Span tag(String key, Boolean value) {
         delegate.setAttribute(key, value);
+        return this;
     }
 
     @Override
-    public void tag(String key, Number value) {
+    public Span tag(String key, Number value) {
         if (value instanceof Double || value instanceof Float) {
             delegate.setAttribute(key, value.doubleValue());
         } else {
             delegate.setAttribute(key, value.longValue());
         }
+        return this;
     }
 
     @Override
@@ -89,6 +96,33 @@ public Scope activate() {
         return new OpenTelemetryScope(delegate.makeCurrent());
     }
 
+    @Override
+    public Span baggage(String key, String value) {
+        Objects.requireNonNull(key, "Baggage Key cannot be null");
+        Objects.requireNonNull(value, "Baggage Value cannot be null");
+
+        Baggage.builder()
+                .put(key, value)
+                .build()
+                .storeInContext(getContext())
+                .makeCurrent();
+        return this;
+    }
+
+    @Override
+    public Optional<String> baggage(String key) {
+        Objects.requireNonNull(key, "Baggage Key cannot be null");
+        return Optional.ofNullable(Baggage.fromContext(getContext()).getEntryValue(key));
+    }
+
+    // Check if OTEL Context is already available in Global Helidon Context.
+    // If not – use Current context.
+    private static Context getContext() {
+        return Contexts.context()
+                .flatMap(ctx -> ctx.get(Context.class))
+                .orElseGet(Context::current);
+    }
+
     private Attributes toAttributes(Map<String, ?> attributes) {
         AttributesBuilder builder = Attributes.builder();
         attributes.forEach((key, value) -> {

tracing/opentelemetry/src/test/java/io/helidon/tracing/opentelemetery/BaggageTest.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2023 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.tracing.opentelemetery;
+
+import java.util.Optional;
+
+import io.helidon.tracing.Span;
+import io.helidon.tracing.Tracer;
+import io.helidon.tracing.TracerBuilder;
+
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * Test if baggage is handled correctly.
+ */
+class BaggageTest {
+
+    private final Tracer tracer = TracerBuilder.create("test-service").registerGlobal(false).build();
+
+    @Test
+    void testBaggage(){
+        Span span = tracer.spanBuilder("test-span").start();
+        Span spanWithBaggage = span.baggage("key", "value");
+        Optional<String> result = spanWithBaggage.baggage("key");
+        span.end();
+        assertThat(result.isPresent(), is(true));
+        assertThat(result.get(), equalTo("value"));
+    }
+
+    @Test
+    void testBadBaggage(){
+        Span span = tracer.spanBuilder("test-bad-span").start();
+        assertThrows(NullPointerException.class, () -> span.baggage(null, "value"));
+        assertThrows(NullPointerException.class, () -> span.baggage("key", null));
+        assertThrows(NullPointerException.class, () -> span.baggage(null, null));
+    }
+}

tracing/opentracing/src/main/java/io/helidon/tracing/opentracing/OpenTracingSpan.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2023 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,6 +17,8 @@
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
 
 import io.helidon.tracing.Scope;
 import io.helidon.tracing.Span;
@@ -38,18 +40,21 @@ class OpenTracingSpan implements Span {
 
 
     @Override
-    public void tag(String key, String value) {
+    public Span tag(String key, String value) {
         delegate.setTag(key, value);
+        return this;
     }
 
     @Override
-    public void tag(String key, Boolean value) {
+    public Span tag(String key, Boolean value) {
         delegate.setTag(key, value);
+        return this;
     }
 
     @Override
-    public void tag(String key, Number value) {
+    public Span tag(String key, Number value) {
         delegate.setTag(key, value);
+        return this;
     }
 
     @Override
@@ -91,6 +96,22 @@ public Scope activate() {
         return new OpenTracingScope(tracer.activateSpan(delegate));
     }
 
+    @Override
+    public Span baggage(String key, String value) {
+        Objects.requireNonNull(key, "Baggage Key cannot be null");
+        Objects.requireNonNull(value, "Baggage Value cannot be null");
+
+        delegate.setBaggageItem(key, value);
+        return this;
+    }
+
+    @Override
+    public Optional<String> baggage(String key) {
+        Objects.requireNonNull(key, "Baggage Key cannot be null");
+
+        return Optional.ofNullable(delegate.getBaggageItem(key));
+    }
+
     @Override
     public <T> T unwrap(Class<T> spanClass) {
         if (spanClass.isAssignableFrom(delegate.getClass())) {

tracing/tracing/src/main/java/io/helidon/tracing/NoOpTracer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2023 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -96,18 +96,18 @@ public Span start(Instant instant) {
     private static class Span implements io.helidon.tracing.Span {
 
         @Override
-        public void tag(String key, String value) {
-
+        public io.helidon.tracing.Span tag(String key, String value) {
+            return this;
         }
 
         @Override
-        public void tag(String key, Boolean value) {
-
+        public io.helidon.tracing.Span tag(String key, Boolean value) {
+            return this;
         }
 
         @Override
-        public void tag(String key, Number value) {
-
+        public io.helidon.tracing.Span tag(String key, Number value) {
+            return this;
         }
 
         @Override
@@ -133,9 +133,19 @@ public void end(Throwable t) {
         }
 
         @Override
-        public io.helidon.tracing.Scope activate() {
+        public Scope activate() {
             return SCOPE;
         }
+
+        @Override
+        public Span baggage(String key, String value) {
+            return this;
+        }
+
+        @Override
+        public Optional<String> baggage(String key) {
+            return Optional.empty();
+        }
     }
 
     private static class SpanContext implements io.helidon.tracing.SpanContext {

tracing/tracing/src/main/java/io/helidon/tracing/Span.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2023 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -43,34 +43,39 @@ static Optional<Span> current() {
      * Add a tag to this span.
      *
      * @param tag tag to add
+     * @return current span
      */
-    default void tag(Tag<?> tag) {
+    default Span tag(Tag<?> tag) {
         tag.apply(this);
+        return this;
     }
 
     /**
      * Add a string tag.
      *
      * @param key   tag key
      * @param value tag value
+     * @return current span
      */
-    void tag(String key, String value);
+    Span tag(String key, String value);
 
     /**
      * Add a boolean tag.
      *
      * @param key   tag key
      * @param value tag value
+     * @return current span
      */
-    void tag(String key, Boolean value);
+    Span tag(String key, Boolean value);
 
     /**
      * Add a numeric tag.
      *
      * @param key   tag key
      * @param value tag value
+     * @return current span
      */
-    void tag(String key, Number value);
+    Span tag(String key, Number value);
 
     /**
      * Span status, mostly used to configure {@link Status#ERROR}.
@@ -116,6 +121,23 @@ default void tag(Tag<?> tag) {
      */
     Scope activate();
 
+    /**
+     * Sets a baggage item in the Span (and its SpanContext) as a key/value pair.
+     *
+     * @param key String Key
+     * @param value String Value
+     * @return current Span instance
+     */
+    Span baggage(String key, String value);
+
+    /**
+     * Get Baggage Item by key.
+     *
+     * @param key String key
+     * @return {@link Optional} of the value of the baggage item
+     */
+    Optional<String> baggage(String key);
+
     /**
      * Add a new event to this span.
      *