Added Http Trace Context

api/include/opentelemetry/context/context_value.h

@@ -7,12 +7,13 @@
 #include "opentelemetry/nostd/unique_ptr.h"
 #include "opentelemetry/nostd/variant.h"
 #include "opentelemetry/trace/span_context.h"
+#include "opentelemetry/trace/span.h"
 #include "opentelemetry/version.h"
 
 OPENTELEMETRY_BEGIN_NAMESPACE
 namespace context
 {
 using ContextValue =
-    nostd::variant<bool, int64_t, uint64_t, double, nostd::shared_ptr<trace::SpanContext>>;
+    nostd::variant<bool, int64_t, uint64_t, double, nostd::shared_ptr<trace::SpanContext>, nostd::shared_ptr<trace::Span>>;
 }  // namespace context
-OPENTELEMETRY_END_NAMESPACE
+OPENTELEMETRY_END_NAMESPACE

api/include/opentelemetry/propagators/composite_http_propagator.h

@@ -0,0 +1,65 @@
+// Copyright 2020, OpenTelemetry Authors
+//
+// 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.
+
+#pragma once
+
+#include "opentelemetry/context/context.h"
+#include "opentelemetry/trace/propagation/httptextformat.h"
+#include "opentelemetry/nostd/span.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace propagators
+{
+    // CompositeHTTPPropagator provides a mechanism for combining multiple
+    // propagators into a single one.
+    template <typename T>
+    class CompositeHTTPPropagator(trace::propagation::HTTPTextFormat<T>) {
+        public:
+            // Rules that manages how context will be extracted from carrier.
+            using Getter = nostd::string_view(*)(const 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_view trace_description);
+
+            // Initializes a Composite Http Propagator with given propagators
+            CompositeHTTPPropagator(nostd::span<trace::propagation::HTTPTextFormat> &propagators) {
+                this.propagators_ = propagators;
+            }
+
+            // Run each of the configured propagators with the given context and carrier.
+            // Propagators are run in the order they are configured, if multiple
+            // propagators write the same context key, the propagator later in the list
+            // will override previous propagators.
+            // See opentelemetry.trace.propagation.httptextformat.HTTPTextFormat.extract
+            Extract(Getter get_from_carrier, const T &carrier, Context &context) {
+                for (nostd::span<trace::propagation::HTTPTextFormat>::iterator it = propagators_.begin(); it != propagators_.end(); it++) {
+                    context = it->Extract(get_from_carrier, carrier, context);
+                }
+                return context;
+            }
+
+            // Run each of the configured propagators with the given context and carrier.
+            // Propagators are run in the order they are configured, if multiple
+            // propagators write the same carrier key, the propagator later in the list
+            // will override previous propagators.
+            // See `opentelemetry.trace.propagation.httptextformat.HTTPTextFormat.inject`
+            Inject(Setter set_from_carrier, T &carrier, const Context &context) {
+                for (nostd::span<trace::propagation::HTTPTextFormat>::iterator it = propagators_.begin(); it != propagators_.end(); it++) {
+                    it->Inject(get_from_carrier, carrier, context);
+                }
+            }
+        private:
+            nostd::span<trace::propagation::HTTPTextFormat> propagators_;
+    }
+}

api/include/opentelemetry/trace/default_span.h

@@ -0,0 +1,84 @@
+#pragma once
+#include "opentelemetry/trace/span.h"
+#include "opentelemetry/trace/span_context.h"
+#include "opentelemetry/trace/canonical_code.h"
+#include "opentelemetry/common/attribute_value.h"
+#include "opentelemetry/trace/span.h"
+//#include "opentelemetry/trace/tracer.h"
+
+#define pass
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace trace {
+class DefaultSpan: public Span {
+  public:
+    // Returns an invalid span.
+    static DefaultSpan GetInvalid() {
+        return DefaultSpan(SpanContext::GetInvalid());
+    }
+
+    trace::SpanContext GetContext() const noexcept {
+        return span_context_;
+    }
+
+    bool IsRecording() const noexcept {
+        return false;
+    }
+
+    void SetAttribute(nostd::string_view key, const common::AttributeValue &value) noexcept {
+      pass;
+    }
+
+    void AddEvent(nostd::string_view name) noexcept { pass; }
+
+    void AddEvent(nostd::string_view name, core::SystemTimestamp timestamp) noexcept { pass; }
+
+    void AddEvent(nostd::string_view name,
+                          core::SystemTimestamp timestamp,
+                          const KeyValueIterable &attributes) noexcept { pass; }
+
+    void AddEvent(nostd::string_view name, const KeyValueIterable &attributes) noexcept
+    {
+      this->AddEvent(name, std::chrono::system_clock::now(), attributes);
+    }
+
+    void SetStatus(CanonicalCode status, nostd::string_view description) noexcept {
+      pass;
+    }
+
+    void UpdateName(nostd::string_view name) noexcept {
+      pass;
+    }
+
+    void End(const EndSpanOptions &options = {}) noexcept {
+      pass;
+    }
+
+    nostd::string_view ToString() {
+      return "DefaultSpan";
+    }
+
+    DefaultSpan() = default;
+
+    DefaultSpan(SpanContext span_context) {
+       this->span_context_ = span_context;
+    }
+
+    // movable and copiable
+    DefaultSpan(DefaultSpan&& spn) : span_context_(spn.GetContext()) {}
+    DefaultSpan(const DefaultSpan& spn) : span_context_(spn.GetContext()) {}
+
+    trace::Tracer &tracer() noexcept {
+      return tracer_; // Invalid tracer
+    }
+
+    // Creates an instance of this class with spancontext.
+    static DefaultSpan Create(SpanContext span_context) {
+      return DefaultSpan(span_context);
+    }
+
+  private:
+    SpanContext span_context_;
+    trace::Tracer tracer_;
+};
+}
+OPENTELEMETRY_END_NAMESPACE

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

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <cstdint>
+#include "opentelemetry/context/context.h"
+#include "opentelemetry/nostd/string_view.h"
+//#include "opentelemetry/trace/span.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace trace
+{
+namespace propagation
+{
+
+// 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(*)(const 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_view trace_description);
+
+        // Returns the context that is stored in the HTTP header carrier with self defined rules.
+        virtual context::Context Extract(Getter get_from_carrier, const T &carrier, context::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 &context) = 0;
+
+//        // Set the span in the given context.
+//        virtual context::Context SetSpanInContext(trace::Span* span, context::Context &context) = 0;
+//        // Retrieve the current span.
+//        virtual trace::Span* GetCurrentSpan(context::Context &context) = 0;
+};
+}
+}
+OPENTELEMETRY_END_NAMESPACE