service_tracing.hpp

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#include "azure/core/context.hpp"
#include "azure/core/internal/client_options.hpp"
#include "azure/core/internal/extendable_enumeration.hpp"
#include "azure/core/internal/tracing/tracing_impl.hpp"
 
#include <utility>
 
#pragma once
 
namespace Azure { namespace Core { namespace Tracing { namespace _internal {
 
  class ServiceSpan final : public Span {
  private:
    std::shared_ptr<Span> m_span;
 
    friend class TracingContextFactory;
    ServiceSpan() = default;
    explicit ServiceSpan(std::shared_ptr<Span> span) : m_span(std::move(span)) {}
 
    ServiceSpan(const ServiceSpan&) = delete;
    ServiceSpan& operator=(ServiceSpan const&) = delete;
 
    ServiceSpan& operator=(ServiceSpan&&) noexcept = default;
 
  public:
    ServiceSpan(ServiceSpan&& that) = default;
 
    ~ServiceSpan() override
    {
      if (m_span)
      {
        m_span->End({});
      }
    }
 
    void End() { End({}); }
 
    void End(Azure::Nullable<Azure::DateTime> endTime) override
    {
      if (m_span)
      {
        m_span->End(endTime);
      }
    }
    void SetStatus(Azure::Core::Tracing::_internal::SpanStatus const& status)
    {
      SetStatus(status, {});
    }
    void SetStatus(
        Azure::Core::Tracing::_internal::SpanStatus const& status,
        std::string const& description) override
    {
      if (m_span)
      {
        m_span->SetStatus(status, description);
      }
    }
 
    void AddAttributes(AttributeSet const& attributeToAdd) override
    {
      if (m_span)
      {
        m_span->AddAttributes(attributeToAdd);
      }
    }
 
    void AddAttribute(std::string const& attributeName, std::string const& attributeValue) override
    {
      if (m_span)
      {
        m_span->AddAttribute(attributeName, attributeValue);
      }
    }
 
    void AddEvent(std::string const& eventName, AttributeSet const& eventAttributes) override
    {
      if (m_span)
      {
        m_span->AddEvent(eventName, eventAttributes);
      }
    }
 
    void AddEvent(std::string const& eventName) override
    {
      if (m_span)
      {
        m_span->AddEvent(eventName);
      }
    }
 
    void AddEvent(std::exception const& exception) override
    {
      if (m_span)
      {
        m_span->AddEvent(exception);
        m_span->SetStatus(SpanStatus::Error, {});
      }
    }
 
    void PropagateToHttpHeaders(Azure::Core::Http::Request& request) override
    {
      if (m_span)
      {
        m_span->PropagateToHttpHeaders(request);
      }
    }
  };
 
  class TracingContextFactory final {
  private:
    std::string m_serviceName;
    std::string m_packageName;
    std::string m_packageVersion;
    std::shared_ptr<Azure::Core::Tracing::_internal::Tracer> m_serviceTracer;
 
    static Azure::Core::Context::Key ContextSpanKey;
    static Azure::Core::Context::Key TracingFactoryContextKey;
 
  public:
    TracingContextFactory(
        Azure::Core::_internal::ClientOptions const& options,
        std::string const& serviceName,
        std::string const& packageName,
        std::string packageVersion)
        : m_serviceName{serviceName}, m_packageName{packageName}, m_packageVersion{packageVersion}
    {
      // If the caller has configured a tracing provider, use it. Otherwise, use the default
      // provider.
      if (options.Telemetry.TracingProvider)
      {
        m_serviceTracer
            = Azure::Core::Tracing::_internal::TracerProviderImplGetter::TracerImplFromTracer(
                  options.Telemetry.TracingProvider)
                  ->CreateTracer(packageName, packageVersion);
      }
    }
    [[deprecated]] TracingContextFactory(
        Azure::Core::_internal::ClientOptions const& options,
        std::string const& serviceName,
        std::string packageVersion)
        : TracingContextFactory(options, serviceName, serviceName, packageVersion)
    {
    }
 
    TracingContextFactory() = default;
    TracingContextFactory(TracingContextFactory const&) = default;
 
    struct TracingContext
    {
      Azure::Core::Context Context;
      ServiceSpan Span;
    };
 
    TracingContext CreateTracingContext(
        std::string const& spanName,
        Azure::Core::Context const& context) const;
 
    TracingContext CreateTracingContext(
        std::string const& spanName,
        Azure::Core::Tracing::_internal::CreateSpanOptions& spanOptions,
        Azure::Core::Context const& context) const;
 
    std::unique_ptr<Azure::Core::Tracing::_internal::AttributeSet> CreateAttributeSet() const;
 
    bool HasTracer() const { return static_cast<bool>(m_serviceTracer); }
 
    static std::unique_ptr<TracingContextFactory> CreateFromContext(
        Azure::Core::Context const& context);
  };
 
  class TracingAttributes
      : public Azure::Core::_internal::ExtendableEnumeration<TracingAttributes> {
  public:
    explicit TracingAttributes(std::string const& that) : ExtendableEnumeration(that) {}
 
    AZ_CORE_DLLEXPORT const static TracingAttributes AzNamespace;
 
    AZ_CORE_DLLEXPORT const static TracingAttributes RequestId;
 
    AZ_CORE_DLLEXPORT const static TracingAttributes ServiceRequestId;
 
    AZ_CORE_DLLEXPORT const static TracingAttributes HttpMethod;
 
    AZ_CORE_DLLEXPORT const static TracingAttributes HttpUrl;
 
    AZ_CORE_DLLEXPORT const static TracingAttributes HttpStatusCode;
 
    AZ_CORE_DLLEXPORT const static TracingAttributes HttpUserAgent;
 
    AZ_CORE_DLLEXPORT const static TracingAttributes NetPeerName;
 
    AZ_CORE_DLLEXPORT const static TracingAttributes NetPeerPort;
  };
 
}}}} // namespace Azure::Core::Tracing::_internal