.. _program_listing_file_include_opentelemetry_trace_tracer.h:

Program Listing for File tracer.h
=================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_opentelemetry_trace_tracer.h>` (``include/opentelemetry/trace/tracer.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   #include "opentelemetry/nostd/shared_ptr.h"
   #include "opentelemetry/nostd/string_view.h"
   #include "opentelemetry/nostd/unique_ptr.h"
   #include "opentelemetry/trace/default_span.h"
   #include "opentelemetry/trace/scope.h"
   #include "opentelemetry/trace/span.h"
   #include "opentelemetry/trace/span_context_kv_iterable_view.h"
   #include "opentelemetry/version.h"
   
   #include <chrono>
   
   OPENTELEMETRY_BEGIN_NAMESPACE
   namespace trace
   {
   class Tracer
   {
   public:
     virtual ~Tracer() = default;
     virtual nostd::shared_ptr<Span> StartSpan(nostd::string_view name,
                                               const common::KeyValueIterable &attributes,
                                               const SpanContextKeyValueIterable &links,
                                               const StartSpanOptions &options = {}) noexcept = 0;
   
     nostd::shared_ptr<Span> StartSpan(nostd::string_view name,
                                       const StartSpanOptions &options = {}) noexcept
     {
       return this->StartSpan(name, {}, {}, options);
     }
   
     template <class T,
               nostd::enable_if_t<common::detail::is_key_value_iterable<T>::value> * = nullptr>
     nostd::shared_ptr<Span> StartSpan(nostd::string_view name,
                                       const T &attributes,
                                       const StartSpanOptions &options = {}) noexcept
     {
       return this->StartSpan(name, attributes, {}, options);
     }
   
     nostd::shared_ptr<Span> StartSpan(nostd::string_view name,
                                       const common::KeyValueIterable &attributes,
                                       const StartSpanOptions &options = {}) noexcept
     {
       return this->StartSpan(name, attributes, NullSpanContext(), options);
     }
   
     template <class T,
               class U,
               nostd::enable_if_t<common::detail::is_key_value_iterable<T>::value> * = nullptr,
               nostd::enable_if_t<detail::is_span_context_kv_iterable<U>::value> *   = nullptr>
     nostd::shared_ptr<Span> StartSpan(nostd::string_view name,
                                       const T &attributes,
                                       const U &links,
                                       const StartSpanOptions &options = {}) noexcept
     {
       return this->StartSpan(name, common::KeyValueIterableView<T>(attributes),
                              SpanContextKeyValueIterableView<U>(links), options);
     }
   
     nostd::shared_ptr<Span> StartSpan(
         nostd::string_view name,
         std::initializer_list<std::pair<nostd::string_view, common::AttributeValue>> attributes,
         const StartSpanOptions &options = {}) noexcept
     {
   
       return this->StartSpan(name, attributes, {}, options);
     }
   
     template <class T,
               nostd::enable_if_t<common::detail::is_key_value_iterable<T>::value> * = nullptr>
     nostd::shared_ptr<Span> StartSpan(
         nostd::string_view name,
         const T &attributes,
         std::initializer_list<
             std::pair<SpanContext,
                       std::initializer_list<std::pair<nostd::string_view, common::AttributeValue>>>>
             links,
         const StartSpanOptions &options = {}) noexcept
     {
       return this->StartSpan(
           name, attributes,
           nostd::span<const std::pair<SpanContext, std::initializer_list<std::pair<
                                                        nostd::string_view, common::AttributeValue>>>>{
               links.begin(), links.end()},
           options);
     }
   
     template <class T,
               nostd::enable_if_t<common::detail::is_key_value_iterable<T>::value> * = nullptr>
     nostd::shared_ptr<Span> StartSpan(
         nostd::string_view name,
         std::initializer_list<std::pair<nostd::string_view, common::AttributeValue>> attributes,
         const T &links,
         const StartSpanOptions &options = {}) noexcept
     {
       return this->StartSpan(name,
                              nostd::span<const std::pair<nostd::string_view, common::AttributeValue>>{
                                  attributes.begin(), attributes.end()},
                              links, options);
     }
   
     nostd::shared_ptr<Span> StartSpan(
         nostd::string_view name,
         std::initializer_list<std::pair<nostd::string_view, common::AttributeValue>> attributes,
         std::initializer_list<
             std::pair<SpanContext,
                       std::initializer_list<std::pair<nostd::string_view, common::AttributeValue>>>>
             links,
         const StartSpanOptions &options = {}) noexcept
     {
       return this->StartSpan(
           name,
           nostd::span<const std::pair<nostd::string_view, common::AttributeValue>>{attributes.begin(),
                                                                                    attributes.end()},
           nostd::span<const std::pair<SpanContext, std::initializer_list<std::pair<
                                                        nostd::string_view, common::AttributeValue>>>>{
               links.begin(), links.end()},
           options);
     }
   
     nostd::unique_ptr<Scope> WithActiveSpan(nostd::shared_ptr<Span> &span) noexcept
     {
       return nostd::unique_ptr<Scope>(new Scope{span});
     }
   
     nostd::shared_ptr<Span> GetCurrentSpan() noexcept
     {
       context::ContextValue active_span = context::RuntimeContext::GetValue(kSpanKey);
       if (nostd::holds_alternative<nostd::shared_ptr<Span>>(active_span))
       {
         return nostd::get<nostd::shared_ptr<Span>>(active_span);
       }
       else
       {
         return nostd::shared_ptr<Span>(new DefaultSpan(SpanContext::GetInvalid()));
       }
     }
   
     template <class Rep, class Period>
     void ForceFlush(std::chrono::duration<Rep, Period> timeout) noexcept
     {
       this->ForceFlushWithMicroseconds(
           static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::microseconds>(timeout)));
     }
   
     virtual void ForceFlushWithMicroseconds(uint64_t timeout) noexcept = 0;
   
     template <class Rep, class Period>
     void Close(std::chrono::duration<Rep, Period> timeout) noexcept
     {
       this->CloseWithMicroseconds(
           static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::microseconds>(timeout)));
     }
   
     virtual void CloseWithMicroseconds(uint64_t timeout) noexcept = 0;
   };
   }  // namespace trace
   OPENTELEMETRY_END_NAMESPACE