tracing.hpp

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "azure/core/datetime.hpp"
#include "azure/core/internal/extendable_enumeration.hpp"
#include "azure/core/nullable.hpp"
#include "azure/core/url.hpp"
#include <array>
#include <memory>
#include <string>
#include <vector>
 
// Forward declare Azure::Core::Http::Request to resolve an include file ordering problem.
namespace Azure { namespace Core { namespace Http {
  class Request;
}}} // namespace Azure::Core::Http
 
namespace Azure { namespace Core { namespace Tracing {
 
  namespace _internal {
 
    class AttributeSet {
    public:
      virtual void AddAttribute(std::string const& attributeName, bool value) = 0;
      virtual void AddAttribute(std::string const& attributeName, int32_t value) = 0;
      virtual void AddAttribute(std::string const& attributeName, int64_t value) = 0;
      virtual void AddAttribute(std::string const& attributeName, uint64_t value) = 0;
      virtual void AddAttribute(std::string const& attributeName, double value) = 0;
      virtual void AddAttribute(std::string const& attributeName, const char* value) = 0;
      virtual void AddAttribute(std::string const& attributeName, std::string const& value) = 0;
 
      virtual ~AttributeSet() = default;
    };
 
    class SpanKind final : public Azure::Core::_internal::ExtendableEnumeration<SpanKind> {
    public:
      explicit SpanKind(std::string const& kind) : ExtendableEnumeration(kind) {}
      SpanKind() = default;
 
      AZ_CORE_DLLEXPORT const static SpanKind Internal;
      AZ_CORE_DLLEXPORT const static SpanKind Client;
      AZ_CORE_DLLEXPORT const static SpanKind Server;
      AZ_CORE_DLLEXPORT const static SpanKind Producer;
      AZ_CORE_DLLEXPORT const static SpanKind Consumer;
    };
 
    class SpanStatus final : public Azure::Core::_internal::ExtendableEnumeration<SpanStatus> {
 
    public:
      explicit SpanStatus(std::string const& status) : ExtendableEnumeration(status) {}
      SpanStatus() = default;
 
      AZ_CORE_DLLEXPORT const static SpanStatus Unset;
      AZ_CORE_DLLEXPORT const static SpanStatus Ok;
      AZ_CORE_DLLEXPORT const static SpanStatus Error;
    };
 
    class Span {
    public:
      virtual void End(Azure::Nullable<Azure::DateTime> endTime = {}) = 0;
 
      virtual void AddAttributes(AttributeSet const& attributeToAdd) = 0;
 
      virtual void AddAttribute(std::string const& attributeName, std::string const& attributeValue)
          = 0;
 
      virtual void AddEvent(std::string const& eventName, AttributeSet const& eventAttributes) = 0;
 
      virtual void AddEvent(std::string const& eventName) = 0;
      virtual void AddEvent(std::exception const& exception) = 0;
 
      virtual void SetStatus(SpanStatus const& status, std::string const& description = "") = 0;
 
      virtual void PropagateToHttpHeaders(Azure::Core::Http::Request& request) = 0;
    };
 
    struct CreateSpanOptions final
    {
      SpanKind Kind{SpanKind::Internal};
      std::unique_ptr<AttributeSet> Attributes;
 
      std::shared_ptr<Span> ParentSpan;
    };
 
    class Tracer {
    public:
      virtual std::shared_ptr<Span> CreateSpan(
          std::string const& spanName,
          CreateSpanOptions const& options = {}) const = 0;
 
      virtual std::unique_ptr<AttributeSet> CreateAttributeSet() const = 0;
    };
  } // namespace _internal
 
  class TracerProvider {
  public:
    virtual std::shared_ptr<Azure::Core::Tracing::_internal::Tracer> CreateTracer(
        std::string const& name,
        std::string const& version = "") const = 0;
  };
}}} // namespace Azure::Core::Tracing