Added Http Trace Context

.gitignore

@@ -34,3 +34,8 @@
 
 # Bazel files
 /bazel-*
+/.idea/
+/.idea/.gitignore
+/.idea/modules.xml
+/.idea/opentelemetry-cpp.iml
+/.idea/vcs.xml

api/include/opentelemetry/trace/default_span.cc

@@ -0,0 +1,37 @@
+#include "opentelemetry/trace/span.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace trace {
+public const class DefaultSpan : Span {
+  public:
+    // Returns an invalid span.
+    static DefaultSpan getInvalid() {
+        return INVALID;
+    }
+
+    // Creates an instance of this class with spancontext.
+    static DefaultSpan create(SpanContext spanContext) {
+      return DefaultSpan(spanContext);
+    }
+
+    static DefaultSpan createRandom() {
+      return DefaultSpan(
+        SpanContext(
+          TraceId.generateRandomId(),
+          SpanId.generateRandomId(),
+          false,
+          TraceFlags.getDefault(),
+          TraceState.getDefault()
+        )
+      );
+    }
+
+    DefaultSpan(SpanContext spanContext) {
+       this.spanContext = spanContext;
+    }
+
+  private:
+    static const DefaultSpan INVALID = new DefaultSpan(SpanContext.getInvalid());
+    const SpanContext spanContext;
+}
+}

api/include/opentelemetry/trace/propagation/HttpTraceContext.cc

@@ -0,0 +1,183 @@
+#include <vector>
+#include <regex>
+#include <stdexcept>
+#include "opentelemetry/trace/propagation/httptextformat.h"
+#include "opentelemetry/trace/spancontext.h"
+#include "opentelemetry/trace/trace_state.h"
+#include "opentelemetry/context/context.h"
+#include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/trace/span.h"
+#include "opentelemetry/trace/default_span.cc"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace trace
+{
+namespace propagation
+{
+namespace
+{
+
+static Context SetSpanInContext(Span span, Context &context) {
+    Context new_values = Context(context);
+    // I don't know if the SPAN_KEY is defined in the context.h.
+    // My point is that since each key when it is created is unique in terms of its id even though they may have the same name,
+    // it would make sense to define those keys in a single file only and had to be referenced by other files to store and retrieve values,
+    // otherwise I will not be able to access any fields, for example, "current-span" as CreateKey("current-span") will
+    // not work because the id is different when the value is put into despite the Key is also created from
+    // CreateKey("current-span").
+    // Don't know if I get the correct understanding there.
+    new_values.setValue(Context.SPAN_KEY,span);
+    return new_values;
+}
+
+static Span GetCurrentSpan(Context &context) {
+    Span span = get_value(Context.SPAN_KEY, context);
+    if (span == NULL) {
+        return NULL;
+    }
+    return span;
+}
+
+// The HttpTraceContext provides methods to extract and inject
+// context into headers of HTTP requests with traces.
+// Example:
+//    HttpTraceContext.inject(setter,&carrier,&context);
+//    HttpTraceContext.extract(getter,&carrier,&context);
+class HttpTraceContext : public HTTPTextFormat
+{
+    public:
+        List<nostd::string_view> fields() {
+            static const auto* FIELDS = new std::vector<nostd::string_view>({TRACE_PARENT, TRACE_STATE});
+            return FIELDS;
+        }
+
+        void inject(Setter setter, T &carrier, const Context &context) override {
+            common::AttributeValue span = GetCurrentSpan(context);
+            if (span == NULL || !span.getContext().isValid()) {
+                // We don't have span.getContext() in span.h, should we just use span? As well as acquiring validity. (I do know how to implement them though)
+                return;
+            }
+            injectImpl(setter, carrier, span.getContext());
+        }
+
+        Context extract(Getter getter, const T &carrier, Context &context) override {
+            SpanContext spanContext = extractImpl(carrier, getter);
+            return SetSpanInContext(trace.DefaultSpan(spanContext), context);
+        }
+
+    private:
+        static const nostd::string_view TRACE_PARENT = "traceparent";
+        static const nostd::string_view TRACE_STATE = "tracestate";
+        static const int VERSION_BYTES = 2;
+        static const int TRACE_ID_BYTES = 32;
+        static const int PARENT_ID_BYTES = 16;
+        static const int TRACE_FLAG_BYTES = 2;
+        static const int TRACE_DELIMITER_BYTES = 3;
+        static const int HEADER_SIZE = VERSION_BYTES + TRACE_ID_BYTES + PARENT_ID_BYTES + TRACE_FLAG_BYTES + TRACE_DELIMITER_BYTES;
+        static const int TRACESTATE_MAX_MEMBERS = 32;
+        static const nostd::string_view TRACESTATE_KEY_VALUE_DELIMITER = "=";
+        static const std::regex TRACESTATE_ENTRY_DELIMITER_SPLIT_PATTERN("[ \t]*,[ \t]*");
+
+        static Context checkNotNull(Context &arg, nostd::string_view errorMessage) {
+            if (arg == NULL) {
+                throw new NullPointerException("error: null " + errorMessage);
+            }
+            return arg;
+        }
+
+        static void injectImpl(Setter setter, T &carrier, const SpanContext &spanContext) {
+            char hex_string[HEADER_SIZE];
+            sprintf(hex_string, "00-%032x-%016x-%02x",spanContext.trace_id(),spanContext.span_id(),spanContext.trace_flags());
+            nostd::string_view traceparent_string = nostd::string_view(hex_string, HEADER_SIZE);
+            setter(carrier, TRACE_PARENT, traceparent_string);
+            if (spanContext.getTraceState()) {
+                nostd::string_view tracestate_string = formatTracestate(spanContext.getTraceState()); // I need the definition for the type of TraceState(Dictionary or something else). The trace state data structure will determine how I will able to join this together.
+                setter(carrier, TRACE_STATE, tracestate_string);
+            }
+        }
+
+        static SpanContext extractContextFromTraceParent(nostd::string_view &traceparent) {
+            bool isValid = traceparent.length() == HEADER_SIZE
+                            && traceparent[VERSION_BYTES] == "-"
+                            && traceparent[VERSION_BYTES+TRACE_ID_BYTES+1] == "-"
+                            && traceparent[VERSION_BYTES+TRACE_ID_BYTES+PARENT_ID_BYTES+2] == "-";
+            if (!isValid) {
+                std::cout<<"Unparseable traceparent header. Returning INVALID span context."<<std::endl;
+                return SpanContext.getInvalid();
+            }
+
+            try {
+                TraceId traceId = TraceId.fromLowerBase16(traceparent, TRACE_ID_OFFSET);
+                SpanId spanId = SpanId.fromLowerBase16(traceparent, SPAN_ID_OFFSET);
+                TraceFlags traceFlags = TraceFlags.fromLowerBase16(traceparent, TRACE_OPTION_OFFSET);
+                return SpanContext.createFromRemoteParent(traceId, spanId, traceFlags, TRACE_STATE_DEFAULT);
+            } catch (IllegalArgumentException e) {
+                std::cout<<"Unparseable traceparent header. Returning INVALID span context."<<std::endl;
+                return SpanContext.getInvalid();
+            }
+        }
+
+        static TraceState extractTraceState(nostd::string_view traceStateHeader) {
+            // TODO: implementation
+            /** The question here is that how should I treat the trace state. Implementation will differ pretty much
+                depending on what is the data structure of TraceState. Also this is based on the premise that
+                trace state exists and has a builder
+            */
+            std::smatch listMembers;
+            TraceState.Builder traceStateBuilder = TraceState.builder();
+            regex_search(traceStateHeader,sm,TRACESTATE_ENTRY_DELIMITER_SPLIT_PATTERN); // I hope regex accepts string view
+            if (listMembers.size() <= TRACESTATE_MAX_MEMBERS) {
+                throw std::invalid_argument("TraceState has too many elements.");
+            }
+            for (int i = listMembers.size() - 1; i >= 0; i--) {
+                nostd::string_view listMember = listMembers[i];
+                int index = -1;
+                for (int j = 0; j < listMember.length(); j++) {
+                    if (listMember[j] == TRACESTATE_KEY_VALUE_DELIMITER) {
+                        index = j;
+                        break;
+                    }
+                }
+                if (index == -1) {
+                    throw std::invalid_argument("Invalid TraceState list-member format.");
+                }
+                traceStateBuilder.set(listMember.substring(0, index), listMember.substring(index + 1));
+            }
+            return traceStateBuilder.build();
+        }
+
+        static SpanContext extractImpl(Getter getter, T &carrier) {
+            nostd::string_view traceParent = getter(carrier, TRACE_PARENT);
+            if (traceParent == NULL) {
+                return SpanContext.getInvalid();
+            }
+
+            SpanContext contextFromParentHeader = extractContextFromTraceParent(traceParent);
+            if (!contextFromParentHeader.isValid()) {
+                return contextFromParentHeader;
+            }
+
+            nostd::string_view traceStateHeader = getter(carrier, TRACE_STATE);
+            if (traceStateHeader == NULL || traceStateHeader.isEmpty()) {
+                return contextFromParentHeader;
+            }
+
+            try {
+                // Again, the trace state problem, should I treat it like a string or dictionary or an encapsuled class? This is not defined in current files
+                TraceState traceState = extractTraceState(traceStateHeader);
+                // Need getter support from SpanContext
+                return SpanContext.createFromRemoteParent(
+                    contextFromParentHeader.getTraceId(),
+                    contextFromParentHeader.getSpanId(),
+                    contextFromParentHeader.getTraceFlags(),
+                    traceState);
+            } catch (IllegalArgumentException e) {
+                std::cout<<"Unparseable tracestate header. Returning span context without state."<<std::endl;
+                return contextFromParentHeader;
+            }
+        }
+}
+}
+}
+}  // namespace trace
+OPENTELEMETRY_END_NAMESPACE

api/include/opentelemetry/trace/propagation/httptextformat.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <cstdint>
+#include "opentelemetry/context/context.h"
+#include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace trace
+{
+namespace propagation
+{
+
+// Set the span in the given context.
+virtual static Context SetSpanInContext(Span span, Context &context) = 0;
+// Retrieve the current span.
+virtual static Span GetCurrentSpan(Context &context) = 0;
+
+// The HTTPTextFormat class provides an interface that enables extracting and injecting
+// context into headers of HTTP requests. HTTP frameworks and clients
+// can integrate with HTTPTextFormat by providing the object containing the
+//  headers, and a getter and setter function for the extraction and
+// injection of values, respectively.
+template <typename T>
+class HTTPTextFormat {
+    public:
+        // Rules that manages how context will be extracted from carrier.
+        using Getter = nostd::string_view(*)(T &carrier, nostd::string_view trace_type);
+
+        // Rules that manages how context will be injected to carrier.
+        using Setter = void(*)(T &carrier, nostd::string_view trace_type,nostd::string trace_description);
+
+        // Returns the context that is stored in the HTTP header carrier with self defined rules.
+        virtual Context extract(Getter get_from_carrier, const T &carrier, Context &context) = 0;
+
+        // Sets the context for a HTTP header carrier with self defined rules.
+        virtual void inject(Setter set_from_carrier, T &carrier, const Context &context) = 0;
+};
+}
+}
+OPENTELEMETRY_END_NAMESPACE

api/include/opentelemetry/trace/span_id.h

@@ -47,6 +47,14 @@ class SpanId final
     }
   }
 
+  // Creates a SpanId from traceparent
+  static SpanId fromLowerBase16(nostd::string_view src, int srcOffset)
+  {
+    // I don't really know about what to do with this function
+    // The java implementation has this: return new SpanId(BigendianEncoding.longFromBase16String(src, srcOffset));
+    // But I am not sure if this will suffice here and I don't know what is BigendianEncoding module as well.
+  }
+
   // Returns a nostd::span of the ID.
   nostd::span<const uint8_t, kSize> Id() const noexcept
   {

api/include/opentelemetry/trace/spancontext.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstdint>
+#include "opentelemetry/context/context.h"
+#include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/version.h"
+#include "opentelemetry/trace/trace_id.h"
+#include "opentelemetry/trace/span_id.h"
+#include "opentelemetry/trace/trace_flags.h"
+#include "opentelemetry/trace/trace_state.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace trace
+{
+
+public class SpanContext:
+    // The state of a Span to propagate between processes.
+    // This class includes the immutable attributes of a :class:`.Span` that must
+    // be propagated to a span's children and across process boundaries.
+    public:
+        TraceId traceId;
+        SpanId spanId;
+        bool remote;
+        TraceFlags traceFlags;
+        TraceState traceState;
+        static SpanContext INVALID = SpanContext(TraceId.getInvalid(),SpanId.getInvalid(),false,TraceFlags.getDefault(),TraceState.getDefault());
+
+        SpanContext(TraceId trace_id, SpanId span_id, bool is_remote, TraceFlags &trace_flags, TraceState &trace_state) {
+            traceId = trace_id;
+            spanId = span_id;
+            traceFlags = trace_flags;
+            traceState = trace_state;
+            remote = is_remote;
+        }
+
+        // Creates a new SpanContext that was propagated from a remote parent, with the given
+        // identifiers and options.
+        public static SpanContext createFromRemoteParent(TraceId traceId, SpanId spanId, TraceFlags traceFlags, TraceState traceState) {
+          // Question: what is AutoValue_spanContext, where is it defined?
+          return new AutoValue_SpanContext(traceId, spanId, traceFlags, traceState, /* remote=*/ true);
+        }
+
+        static SpanContext getInvalid() {
+            return INVALID;
+        }
+
+        bool isValid() {
+            // Get whether this `SpanContext` is valid.
+            // A `SpanContext` is said to be invalid if its trace ID or span ID is
+            // invalid (i.e. ``0``).
+            return traceId != INVALID_TRACE_ID && self.span_id != INVALID_SPAN_ID;
+        }
+
+        TraceId getTraceId() {
+            return traceId;
+        }
+
+        SpanId getSpanId() {
+            return spanId;
+        }
+
+        TraceFlags getTraceFlags() {
+            return traceFlags;
+        }
+
+        TraceState getTraceState() {
+            return traceState;
+        }
+}
+OPENTELEMETRY_END_NAMESPACE

api/include/opentelemetry/trace/trace_flags.h

@@ -46,6 +46,14 @@ class TraceFlags final
     buffer[1]             = kHex[(rep_ >> 0) & 0xF];
   }
 
+  // Creates TraceFlags from traceparent
+  static TraceFlags fromLowerBase16(nostd::string_view src, int srcOffset)
+  {
+    // I don't really know about what to do with this function
+    // The java implementation has this: return new TraceFlags(BigendianEncoding.byteFromBase16String(src, srcOffset));
+    // But I am not sure if this will suffice here and I don't know what is BigendianEncoding module as well.
+  }
+
   uint8_t flags() const noexcept { return rep_; }
 
   bool operator==(const TraceFlags &that) const noexcept { return rep_ == that.rep_; }

api/include/opentelemetry/trace/trace_id.h

@@ -53,6 +53,16 @@ class TraceId final
     }
   }
 
+  // Creates a SpanId from traceparent
+  static TraceId fromLowerBase16(nostd::string_view src, int srcOffset)
+  {
+    // I don't really know about what to do with this function
+    // The java implementation has this:  return new TraceId(
+    //                                             BigendianEncoding.longFromBase16String(src, srcOffset),
+    //                                             BigendianEncoding.longFromBase16String(src, srcOffset + BigendianEncoding.LONG_BASE16));
+    // But I am not sure if this will suffice here and I don't know what is BigendianEncoding module as well.
+  }
+
   // Returns a nostd::span of the ID.
   nostd::span<const uint8_t, kSize> Id() const noexcept
   {