span.hpp

#pragma once
 
#include "module.hpp"
#include "attribute_map.hpp"
 
#include <exception>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Telemetry
  {

    class Span : public AttributeMap
    {
 
    public:

      static Span Create(const std::string &name)
      {
        return Span{name};
      }


      static Span Create()
      {
        return {};
      }
 
      Span(const Span &)            = delete;
      Span &operator=(const Span &) = delete;
      Span(Span &&other) noexcept
          : AttributeMap(std::move(other))
          , statusMessage_(std::move(other.statusMessage_))
          , status_(std::move(other.status_))
          
      {
      }
 
      Span &operator=(Span &&other) noexcept
      {
        if (this != &other)
        {
          AttributeMap::operator=(std::move(other));
          statusMessage_ = std::move(other.statusMessage_);
          status_ = other.status_;
        }
        return *this;
      }
 
      ~Span()
      {
        if (!handle_)
          return;
#ifdef __cpp_lib_uncaught_exceptions
        const bool hasUncaughtException = std::uncaught_exceptions() > 0;
#else
        const bool hasUncaughtException = std::uncaught_exception;
#endif
        if (status_ == CExports::CVTSS_Unset && hasUncaughtException)
          status_ = CExports::CVTSS_Error;
 
        Flush();
        CExports::CVTSpanEnd(handle_, status_, (statusMessage_.size()) ? statusMessage_.c_str() : nullptr);
        handle_ = nullptr;
      }


      void Succeed() noexcept
      {
        status_ = CExports::CVTSS_Ok;
      }


      template <class T>
      T Succeed(T &&result)
      {
        status_ = CExports::CVTSS_Ok;
        return std::forward<T>(result);
      }


      void Fail() noexcept
      {
        status_ = CExports::CVTSS_Error;
      }


      void Fail(const std::string &message) noexcept
      {
        statusMessage_ = message;
        status_        = CExports::CVTSS_Error;
      }


      template <class T>
      [[noreturn]] void Raise(const T &error)
      {
        statusMessage_ = error.what();
        status_        = CExports::CVTSS_Error;
        throw error;
      }


      template <class T>
      T Return(T code) noexcept
      {
        status_ = (code) ? CExports::CVTSS_Error : CExports::CVTSS_Ok;
        return code;
      }


      template <class T>
      T ReturnBool(T res) noexcept
      {
        status_ = (res) ? CExports::CVTSS_Ok : CExports::CVTSS_Error;
        return res;
      }


      void SetStatusMessage(const std::string &statusMessage) noexcept
      {
        statusMessage_ = statusMessage;
      }
 
    private:
      explicit Span(const std::string &name) noexcept
          : AttributeMap()
      {
        const auto &module = Module::Get();
        if (!module.WouldTrace())
          return;
        CExports::CVTSPAN handle = nullptr;
        CExports::CVTModuleStartSpan(module.Handle(), name.c_str(), handle);
        handle_ = handle;
      }
 
      Span() noexcept = default;
 
      CExports::CVTSpanStatus status_ = CExports::CVTSS_Unset;
      std::string statusMessage_;
    };
  }  // namespace Telemetry
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb