includes/opentelemetry/sdk/trace/recordable.h

Go to the documentation of this file.

// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
 
#pragma once
 
#include <chrono>
 
#include "opentelemetry/common/attribute_value.h"
#include "opentelemetry/common/timestamp.h"
#include "opentelemetry/nostd/string_view.h"
#include "opentelemetry/sdk/common/empty_attributes.h"
#include "opentelemetry/sdk/instrumentationscope/instrumentation_scope.h"
#include "opentelemetry/trace/span_context.h"
#include "opentelemetry/trace/span_id.h"
#include "opentelemetry/trace/span_metadata.h"
#include "opentelemetry/version.h"
 
// TODO: Create generic short pattern for opentelemetry::common and opentelemetry::trace
 
OPENTELEMETRY_BEGIN_NAMESPACE
namespace common
{
class KeyValueIterable;
}  // namespace common
 
namespace sdk
{
namespace resource
{
class Resource;
}  // namespace resource
 
namespace trace
{
 
using namespace opentelemetry::sdk::instrumentationscope;
class SpanData;
 
class Recordable
{
public:
  virtual ~Recordable() = default;
 
  virtual void SetIdentity(const opentelemetry::trace::SpanContext &span_context,
                           opentelemetry::trace::SpanId parent_span_id) noexcept = 0;
 
  virtual void SetAttribute(nostd::string_view key,
                            const opentelemetry::common::AttributeValue &value) noexcept = 0;
 
  virtual void AddEvent(nostd::string_view name,
                        opentelemetry::common::SystemTimestamp timestamp,
                        const opentelemetry::common::KeyValueIterable &attributes) noexcept = 0;
 
  void AddEvent(nostd::string_view name)
  {
    AddEvent(name, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now()),
             opentelemetry::sdk::GetEmptyAttributes());
  }
 
  void AddEvent(nostd::string_view name, opentelemetry::common::SystemTimestamp timestamp)
  {
    AddEvent(name, timestamp, opentelemetry::sdk::GetEmptyAttributes());
  }
 
  void AddEvent(nostd::string_view name,
                const opentelemetry::common::KeyValueIterable &attributes) noexcept
  {
    AddEvent(name, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now()),
             attributes);
  }
 
  virtual void AddLink(const opentelemetry::trace::SpanContext &span_context,
                       const opentelemetry::common::KeyValueIterable &attributes) noexcept = 0;
 
  void AddLink(opentelemetry::trace::SpanContext span_context)
  {
    AddLink(span_context, opentelemetry::sdk::GetEmptyAttributes());
  }
 
  virtual void SetStatus(opentelemetry::trace::StatusCode code,
                         nostd::string_view description) noexcept = 0;
 
  virtual void SetName(nostd::string_view name) noexcept = 0;
 
  virtual void SetTraceFlags(opentelemetry::trace::TraceFlags /* flags */) noexcept {}
 
  virtual void SetSpanKind(opentelemetry::trace::SpanKind span_kind) noexcept = 0;
 
  virtual void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept = 0;
 
  virtual void SetStartTime(opentelemetry::common::SystemTimestamp start_time) noexcept = 0;
 
  virtual void SetDuration(std::chrono::nanoseconds duration) noexcept = 0;
 
  virtual explicit operator SpanData *() const { return nullptr; }
 
  virtual void SetInstrumentationScope(
      const InstrumentationScope &instrumentation_scope) noexcept = 0;
 
  OPENTELEMETRY_DEPRECATED_MESSAGE("Please use SetInstrumentationScope instead")
  void SetInstrumentationLibrary(const InstrumentationScope &instrumentation_scope) noexcept
  {
    SetInstrumentationScope(instrumentation_scope);
  }
};
}  // namespace trace
}  // namespace sdk
OPENTELEMETRY_END_NAMESPACE