diff --git a/examples/configuration/custom_log_record_exporter.cc b/examples/configuration/custom_log_record_exporter.cc new file mode 100644 index 0000000000..c89faef021 --- /dev/null +++ b/examples/configuration/custom_log_record_exporter.cc @@ -0,0 +1,35 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include "opentelemetry/sdk/common/global_log_handler.h" +#include "opentelemetry/sdk/logs/read_write_log_record.h" +#include "opentelemetry/sdk/logs/recordable.h" + +#include "custom_log_record_exporter.h" + +std::unique_ptr +CustomLogRecordExporter::MakeRecordable() noexcept +{ + auto recordable = std::make_unique(); + return recordable; +} + +opentelemetry::sdk::common::ExportResult CustomLogRecordExporter::Export( + const opentelemetry::nostd::span> + & /* records */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomLogRecordExporter::Export(): YOUR CODE HERE"); + return opentelemetry::sdk::common::ExportResult::kSuccess; +} + +bool CustomLogRecordExporter::ForceFlush(std::chrono::microseconds /* timeout */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomLogRecordExporter::ForceFlush(): YOUR CODE HERE"); + return false; +} + +bool CustomLogRecordExporter::Shutdown(std::chrono::microseconds /* timeout */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomLogRecordExporter::Shutdown(): YOUR CODE HERE"); + return false; +} diff --git a/examples/configuration/custom_log_record_exporter.h b/examples/configuration/custom_log_record_exporter.h new file mode 100644 index 0000000000..b3a19c5569 --- /dev/null +++ b/examples/configuration/custom_log_record_exporter.h @@ -0,0 +1,37 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include +#include +#include + +#include "opentelemetry/nostd/span.h" +#include "opentelemetry/sdk/common/exporter_utils.h" +#include "opentelemetry/sdk/logs/exporter.h" +#include "opentelemetry/sdk/logs/recordable.h" + +class CustomLogRecordExporter : public opentelemetry::sdk::logs::LogRecordExporter +{ +public: + CustomLogRecordExporter(const std::string &comment) : comment_(comment) {} + CustomLogRecordExporter(CustomLogRecordExporter &&) = delete; + CustomLogRecordExporter(const CustomLogRecordExporter &) = delete; + CustomLogRecordExporter &operator=(CustomLogRecordExporter &&) = delete; + CustomLogRecordExporter &operator=(const CustomLogRecordExporter &other) = delete; + ~CustomLogRecordExporter() override = default; + + std::unique_ptr MakeRecordable() noexcept override; + + opentelemetry::sdk::common::ExportResult Export( + const opentelemetry::nostd::span> + &records) noexcept override; + + bool ForceFlush(std::chrono::microseconds timeout) noexcept override; + + bool Shutdown(std::chrono::microseconds timeout) noexcept override; + +private: + std::string comment_; +}; diff --git a/examples/configuration/custom_log_record_exporter_builder.cc b/examples/configuration/custom_log_record_exporter_builder.cc new file mode 100644 index 0000000000..fab5f9f1a6 --- /dev/null +++ b/examples/configuration/custom_log_record_exporter_builder.cc @@ -0,0 +1,31 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include + +#include "opentelemetry/sdk/configuration/document_node.h" +#include "opentelemetry/sdk/configuration/extension_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/logs/exporter.h" + +#include "custom_log_record_exporter.h" +#include "custom_log_record_exporter_builder.h" + +std::unique_ptr CustomLogRecordExporterBuilder::Build( + const opentelemetry::sdk::configuration::ExtensionLogRecordExporterConfiguration *model) const +{ + // Read yaml attributes + std::string comment = model->node->GetRequiredString("comment"); + + auto sdk = std::make_unique(comment); + + return sdk; +} + +void CustomLogRecordExporterBuilder::Register(opentelemetry::sdk::configuration::Registry *registry) +{ + auto builder = std::make_unique(); + registry->SetExtensionLogRecordExporterBuilder("my_custom_log_record_exporter", + std::move(builder)); +} diff --git a/examples/configuration/custom_log_record_exporter_builder.h b/examples/configuration/custom_log_record_exporter_builder.h new file mode 100644 index 0000000000..b360bc0955 --- /dev/null +++ b/examples/configuration/custom_log_record_exporter_builder.h @@ -0,0 +1,22 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +#include "opentelemetry/sdk/configuration/extension_log_record_exporter_builder.h" +#include "opentelemetry/sdk/configuration/extension_log_record_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/logs/exporter.h" + +class CustomLogRecordExporterBuilder + : public opentelemetry::sdk::configuration::ExtensionLogRecordExporterBuilder +{ +public: + static void Register(opentelemetry::sdk::configuration::Registry *registry); + + std::unique_ptr Build( + const opentelemetry::sdk::configuration::ExtensionLogRecordExporterConfiguration *model) + const override; +}; diff --git a/examples/configuration/custom_log_record_processor.cc b/examples/configuration/custom_log_record_processor.cc new file mode 100644 index 0000000000..be9716022a --- /dev/null +++ b/examples/configuration/custom_log_record_processor.cc @@ -0,0 +1,36 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include + +#include "opentelemetry/sdk/common/global_log_handler.h" +#include "opentelemetry/sdk/logs/read_write_log_record.h" +#include "opentelemetry/sdk/logs/recordable.h" + +#include "custom_log_record_processor.h" + +std::unique_ptr +CustomLogRecordProcessor::MakeRecordable() noexcept +{ + auto recordable = std::make_unique(); + return recordable; +} + +void CustomLogRecordProcessor::OnEmit( + std::unique_ptr &&span) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomLogRecordProcessor::OnEnd(): YOUR CODE HERE"); + auto unused = std::move(span); +} + +bool CustomLogRecordProcessor::ForceFlush(std::chrono::microseconds /* timeout */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomLogRecordProcessor::ForceFlush(): YOUR CODE HERE"); + return false; +} + +bool CustomLogRecordProcessor::Shutdown(std::chrono::microseconds /* timeout */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomLogRecordProcessor::Shutdown(): YOUR CODE HERE"); + return false; +} diff --git a/examples/configuration/custom_log_record_processor.h b/examples/configuration/custom_log_record_processor.h new file mode 100644 index 0000000000..81e6125bd0 --- /dev/null +++ b/examples/configuration/custom_log_record_processor.h @@ -0,0 +1,33 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include +#include +#include + +#include "opentelemetry/sdk/logs/processor.h" +#include "opentelemetry/sdk/logs/recordable.h" + +class CustomLogRecordProcessor : public opentelemetry::sdk::logs::LogRecordProcessor +{ +public: + CustomLogRecordProcessor(const std::string &comment) : comment_(comment) {} + CustomLogRecordProcessor(CustomLogRecordProcessor &&) = delete; + CustomLogRecordProcessor(const CustomLogRecordProcessor &) = delete; + CustomLogRecordProcessor &operator=(CustomLogRecordProcessor &&) = delete; + CustomLogRecordProcessor &operator=(const CustomLogRecordProcessor &other) = delete; + ~CustomLogRecordProcessor() override = default; + + std::unique_ptr MakeRecordable() noexcept override; + + void OnEmit(std::unique_ptr &&record) noexcept override; + + bool ForceFlush(std::chrono::microseconds timeout) noexcept override; + + bool Shutdown(std::chrono::microseconds timeout) noexcept override; + +private: + std::string comment_; +}; diff --git a/examples/configuration/custom_log_record_processor_builder.cc b/examples/configuration/custom_log_record_processor_builder.cc new file mode 100644 index 0000000000..ceff65e6f3 --- /dev/null +++ b/examples/configuration/custom_log_record_processor_builder.cc @@ -0,0 +1,33 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include + +#include "opentelemetry/sdk/configuration/document_node.h" +#include "opentelemetry/sdk/configuration/extension_log_record_processor_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/logs/processor.h" + +#include "custom_log_record_processor.h" +#include "custom_log_record_processor_builder.h" + +std::unique_ptr +CustomLogRecordProcessorBuilder::Build( + const opentelemetry::sdk::configuration::ExtensionLogRecordProcessorConfiguration *model) const +{ + // Read yaml attributes + std::string comment = model->node->GetRequiredString("comment"); + + auto sdk = std::make_unique(comment); + + return sdk; +} + +void CustomLogRecordProcessorBuilder::Register( + opentelemetry::sdk::configuration::Registry *registry) +{ + auto builder = std::make_unique(); + registry->SetExtensionLogRecordProcessorBuilder("my_custom_log_record_processor", + std::move(builder)); +} diff --git a/examples/configuration/custom_log_record_processor_builder.h b/examples/configuration/custom_log_record_processor_builder.h new file mode 100644 index 0000000000..14d6663ead --- /dev/null +++ b/examples/configuration/custom_log_record_processor_builder.h @@ -0,0 +1,22 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +#include "opentelemetry/sdk/configuration/extension_log_record_processor_builder.h" +#include "opentelemetry/sdk/configuration/extension_log_record_processor_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/logs/processor.h" + +class CustomLogRecordProcessorBuilder + : public opentelemetry::sdk::configuration::ExtensionLogRecordProcessorBuilder +{ +public: + static void Register(opentelemetry::sdk::configuration::Registry *registry); + + std::unique_ptr Build( + const opentelemetry::sdk::configuration::ExtensionLogRecordProcessorConfiguration *model) + const override; +}; diff --git a/examples/configuration/custom_pull_metric_exporter.cc b/examples/configuration/custom_pull_metric_exporter.cc new file mode 100644 index 0000000000..da542731a7 --- /dev/null +++ b/examples/configuration/custom_pull_metric_exporter.cc @@ -0,0 +1,31 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include "opentelemetry/sdk/common/global_log_handler.h" + +#include "custom_pull_metric_exporter.h" + +opentelemetry::sdk::metrics::AggregationTemporality +CustomPullMetricExporter::GetAggregationTemporality( + opentelemetry::sdk::metrics::InstrumentType /* instrument_type */) const noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomPullMetricExporter::GetAggregationTemporality(): YOUR CODE HERE"); + return opentelemetry::sdk::metrics::AggregationTemporality::kCumulative; +} + +bool CustomPullMetricExporter::OnForceFlush(std::chrono::microseconds /* timeout */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomPullMetricExporter::OnForceFlush(): YOUR CODE HERE"); + return true; +} + +bool CustomPullMetricExporter::OnShutDown(std::chrono::microseconds /* timeout */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomPullMetricExporter::OnShutDown(): YOUR CODE HERE"); + return true; +} + +void CustomPullMetricExporter::OnInitialized() noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomPullMetricExporter::OnInitialized(): YOUR CODE HERE"); +} diff --git a/examples/configuration/custom_pull_metric_exporter.h b/examples/configuration/custom_pull_metric_exporter.h new file mode 100644 index 0000000000..debefdf4a1 --- /dev/null +++ b/examples/configuration/custom_pull_metric_exporter.h @@ -0,0 +1,33 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include +#include + +#include "opentelemetry/sdk/metrics/instruments.h" +#include "opentelemetry/sdk/metrics/metric_reader.h" + +class CustomPullMetricExporter : public opentelemetry::sdk::metrics::MetricReader +{ +public: + CustomPullMetricExporter(const std::string &comment) : comment_(comment) {} + CustomPullMetricExporter(CustomPullMetricExporter &&) = delete; + CustomPullMetricExporter(const CustomPullMetricExporter &) = delete; + CustomPullMetricExporter &operator=(CustomPullMetricExporter &&) = delete; + CustomPullMetricExporter &operator=(const CustomPullMetricExporter &other) = delete; + ~CustomPullMetricExporter() override = default; + + opentelemetry::sdk::metrics::AggregationTemporality GetAggregationTemporality( + opentelemetry::sdk::metrics::InstrumentType instrument_type) const noexcept override; + + bool OnForceFlush(std::chrono::microseconds timeout) noexcept override; + + bool OnShutDown(std::chrono::microseconds timeout) noexcept override; + + void OnInitialized() noexcept override; + +private: + std::string comment_; +}; diff --git a/examples/configuration/custom_pull_metric_exporter_builder.cc b/examples/configuration/custom_pull_metric_exporter_builder.cc new file mode 100644 index 0000000000..480a1ff60a --- /dev/null +++ b/examples/configuration/custom_pull_metric_exporter_builder.cc @@ -0,0 +1,32 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include + +#include "opentelemetry/sdk/configuration/document_node.h" +#include "opentelemetry/sdk/configuration/extension_pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/metrics/metric_reader.h" + +#include "custom_pull_metric_exporter.h" +#include "custom_pull_metric_exporter_builder.h" + +std::unique_ptr CustomPullMetricExporterBuilder::Build( + const opentelemetry::sdk::configuration::ExtensionPullMetricExporterConfiguration *model) const +{ + // Read yaml attributes + std::string comment = model->node->GetRequiredString("comment"); + + auto sdk = std::make_unique(comment); + + return sdk; +} + +void CustomPullMetricExporterBuilder::Register( + opentelemetry::sdk::configuration::Registry *registry) +{ + auto builder = std::make_unique(); + registry->SetExtensionPullMetricExporterBuilder("my_custom_pull_metric_exporter", + std::move(builder)); +} diff --git a/examples/configuration/custom_pull_metric_exporter_builder.h b/examples/configuration/custom_pull_metric_exporter_builder.h new file mode 100644 index 0000000000..94a1458b6f --- /dev/null +++ b/examples/configuration/custom_pull_metric_exporter_builder.h @@ -0,0 +1,22 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +#include "opentelemetry/sdk/configuration/extension_pull_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/extension_pull_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/metrics/metric_reader.h" + +class CustomPullMetricExporterBuilder + : public opentelemetry::sdk::configuration::ExtensionPullMetricExporterBuilder +{ +public: + static void Register(opentelemetry::sdk::configuration::Registry *registry); + + std::unique_ptr Build( + const opentelemetry::sdk::configuration::ExtensionPullMetricExporterConfiguration *model) + const override; +}; diff --git a/examples/configuration/custom_push_metric_exporter.cc b/examples/configuration/custom_push_metric_exporter.cc new file mode 100644 index 0000000000..19aad75416 --- /dev/null +++ b/examples/configuration/custom_push_metric_exporter.cc @@ -0,0 +1,34 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include "opentelemetry/sdk/common/global_log_handler.h" +#include "opentelemetry/sdk/metrics/push_metric_exporter.h" + +#include "custom_push_metric_exporter.h" + +opentelemetry::sdk::common::ExportResult CustomPushMetricExporter::Export( + const opentelemetry::sdk::metrics::ResourceMetrics & /* data */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomPushMetricExporter::Export(): YOUR CODE HERE"); + return opentelemetry::sdk::common::ExportResult::kSuccess; +} + +opentelemetry::sdk::metrics::AggregationTemporality +CustomPushMetricExporter::GetAggregationTemporality( + opentelemetry::sdk::metrics::InstrumentType /* instrument_type */) const noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomPushMetricExporter::GetAggregationTemporality(): YOUR CODE HERE"); + return opentelemetry::sdk::metrics::AggregationTemporality::kCumulative; +} + +bool CustomPushMetricExporter::ForceFlush(std::chrono::microseconds /* timeout */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomPushMetricExporter::ForceFlush(): YOUR CODE HERE"); + return true; +} + +bool CustomPushMetricExporter::Shutdown(std::chrono::microseconds /* timeout */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomPushMetricExporter::Shutdown(): YOUR CODE HERE"); + return true; +} diff --git a/examples/configuration/custom_push_metric_exporter.h b/examples/configuration/custom_push_metric_exporter.h new file mode 100644 index 0000000000..f5222c343c --- /dev/null +++ b/examples/configuration/custom_push_metric_exporter.h @@ -0,0 +1,35 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include +#include + +#include "opentelemetry/sdk/common/exporter_utils.h" +#include "opentelemetry/sdk/metrics/instruments.h" +#include "opentelemetry/sdk/metrics/push_metric_exporter.h" + +class CustomPushMetricExporter : public opentelemetry::sdk::metrics::PushMetricExporter +{ +public: + CustomPushMetricExporter(const std::string &comment) : comment_(comment) {} + CustomPushMetricExporter(CustomPushMetricExporter &&) = delete; + CustomPushMetricExporter(const CustomPushMetricExporter &) = delete; + CustomPushMetricExporter &operator=(CustomPushMetricExporter &&) = delete; + CustomPushMetricExporter &operator=(const CustomPushMetricExporter &other) = delete; + ~CustomPushMetricExporter() override = default; + + opentelemetry::sdk::common::ExportResult Export( + const opentelemetry::sdk::metrics::ResourceMetrics &data) noexcept override; + + opentelemetry::sdk::metrics::AggregationTemporality GetAggregationTemporality( + opentelemetry::sdk::metrics::InstrumentType instrument_type) const noexcept override; + + bool ForceFlush(std::chrono::microseconds timeout) noexcept override; + + bool Shutdown(std::chrono::microseconds timeout) noexcept override; + +private: + std::string comment_; +}; diff --git a/examples/configuration/custom_push_metric_exporter_builder.cc b/examples/configuration/custom_push_metric_exporter_builder.cc new file mode 100644 index 0000000000..c2e76c8036 --- /dev/null +++ b/examples/configuration/custom_push_metric_exporter_builder.cc @@ -0,0 +1,33 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include + +#include "opentelemetry/sdk/configuration/document_node.h" +#include "opentelemetry/sdk/configuration/extension_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/metrics/push_metric_exporter.h" + +#include "custom_push_metric_exporter.h" +#include "custom_push_metric_exporter_builder.h" + +std::unique_ptr +CustomPushMetricExporterBuilder::Build( + const opentelemetry::sdk::configuration::ExtensionPushMetricExporterConfiguration *model) const +{ + // Read yaml attributes + std::string comment = model->node->GetRequiredString("comment"); + + auto sdk = std::make_unique(comment); + + return sdk; +} + +void CustomPushMetricExporterBuilder::Register( + opentelemetry::sdk::configuration::Registry *registry) +{ + auto builder = std::make_unique(); + registry->SetExtensionPushMetricExporterBuilder("my_custom_push_metric_exporter", + std::move(builder)); +} diff --git a/examples/configuration/custom_push_metric_exporter_builder.h b/examples/configuration/custom_push_metric_exporter_builder.h new file mode 100644 index 0000000000..c5ff2fe33f --- /dev/null +++ b/examples/configuration/custom_push_metric_exporter_builder.h @@ -0,0 +1,22 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +#include "opentelemetry/sdk/configuration/extension_push_metric_exporter_builder.h" +#include "opentelemetry/sdk/configuration/extension_push_metric_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/metrics/push_metric_exporter.h" + +class CustomPushMetricExporterBuilder + : public opentelemetry::sdk::configuration::ExtensionPushMetricExporterBuilder +{ +public: + static void Register(opentelemetry::sdk::configuration::Registry *registry); + + std::unique_ptr Build( + const opentelemetry::sdk::configuration::ExtensionPushMetricExporterConfiguration *model) + const override; +}; diff --git a/examples/configuration/custom_sampler.cc b/examples/configuration/custom_sampler.cc new file mode 100644 index 0000000000..1957e8175a --- /dev/null +++ b/examples/configuration/custom_sampler.cc @@ -0,0 +1,35 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include + +#include "opentelemetry/trace/span_context.h" +#include "opentelemetry/trace/trace_state.h" + +#include "custom_sampler.h" + +opentelemetry::sdk::trace::SamplingResult CustomSampler::ShouldSample( + const opentelemetry::trace::SpanContext &parent_context, + opentelemetry::trace::TraceId /* trace_id */, + opentelemetry::nostd::string_view /* name */, + opentelemetry::trace::SpanKind /* span_kind */, + const opentelemetry::common::KeyValueIterable & /* attributes */, + const opentelemetry::trace::SpanContextKeyValueIterable & /* links */) noexcept +{ + if (!parent_context.IsValid()) + { + return {opentelemetry::sdk::trace::Decision::RECORD_AND_SAMPLE, nullptr, + opentelemetry::trace::TraceState::GetDefault()}; + } + else + { + return {opentelemetry::sdk::trace::Decision::RECORD_AND_SAMPLE, nullptr, + parent_context.trace_state()}; + } +} + +opentelemetry::nostd::string_view CustomSampler::GetDescription() const noexcept +{ + return "CustomSampler"; +} diff --git a/examples/configuration/custom_sampler.h b/examples/configuration/custom_sampler.h new file mode 100644 index 0000000000..6bb4113d08 --- /dev/null +++ b/examples/configuration/custom_sampler.h @@ -0,0 +1,38 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +#include "opentelemetry/common/key_value_iterable.h" +#include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/sdk/trace/sampler.h" +#include "opentelemetry/trace/span_context.h" +#include "opentelemetry/trace/span_context_kv_iterable.h" +#include "opentelemetry/trace/span_metadata.h" +#include "opentelemetry/trace/trace_id.h" + +class CustomSampler : public opentelemetry::sdk::trace::Sampler +{ +public: + CustomSampler(const std::string &comment) : comment_(comment) {} + CustomSampler(CustomSampler &&) = delete; + CustomSampler(const CustomSampler &) = delete; + CustomSampler &operator=(CustomSampler &&) = delete; + CustomSampler &operator=(const CustomSampler &other) = delete; + ~CustomSampler() override = default; + + opentelemetry::sdk::trace::SamplingResult ShouldSample( + const opentelemetry::trace::SpanContext &parent_context, + opentelemetry::trace::TraceId trace_id, + opentelemetry::nostd::string_view name, + opentelemetry::trace::SpanKind span_kind, + const opentelemetry::common::KeyValueIterable &attributes, + const opentelemetry::trace::SpanContextKeyValueIterable &links) noexcept override; + + opentelemetry::nostd::string_view GetDescription() const noexcept override; + +private: + std::string comment_; +}; diff --git a/examples/configuration/custom_sampler_builder.cc b/examples/configuration/custom_sampler_builder.cc new file mode 100644 index 0000000000..9689620976 --- /dev/null +++ b/examples/configuration/custom_sampler_builder.cc @@ -0,0 +1,28 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include + +#include "opentelemetry/sdk/configuration/document_node.h" +#include "opentelemetry/sdk/configuration/registry.h" + +#include "custom_sampler.h" +#include "custom_sampler_builder.h" + +std::unique_ptr CustomSamplerBuilder::Build( + const opentelemetry::sdk::configuration::ExtensionSamplerConfiguration *model) const +{ + // Read yaml attributes + std::string comment = model->node->GetRequiredString("comment"); + + auto sdk = std::make_unique(comment); + + return sdk; +} + +void CustomSamplerBuilder::Register(opentelemetry::sdk::configuration::Registry *registry) +{ + auto builder = std::make_unique(); + registry->SetExtensionSamplerBuilder("my_custom_sampler", std::move(builder)); +} diff --git a/examples/configuration/custom_sampler_builder.h b/examples/configuration/custom_sampler_builder.h new file mode 100644 index 0000000000..001a8193ba --- /dev/null +++ b/examples/configuration/custom_sampler_builder.h @@ -0,0 +1,20 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +#include "opentelemetry/sdk/configuration/extension_sampler_builder.h" +#include "opentelemetry/sdk/configuration/extension_sampler_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/trace/sampler.h" + +class CustomSamplerBuilder : public opentelemetry::sdk::configuration::ExtensionSamplerBuilder +{ +public: + static void Register(opentelemetry::sdk::configuration::Registry *registry); + + std::unique_ptr Build( + const opentelemetry::sdk::configuration::ExtensionSamplerConfiguration *model) const override; +}; diff --git a/examples/configuration/custom_span_exporter.cc b/examples/configuration/custom_span_exporter.cc new file mode 100644 index 0000000000..285516500a --- /dev/null +++ b/examples/configuration/custom_span_exporter.cc @@ -0,0 +1,34 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include "opentelemetry/sdk/common/global_log_handler.h" +#include "opentelemetry/sdk/trace/recordable.h" +#include "opentelemetry/sdk/trace/span_data.h" + +#include "custom_span_exporter.h" + +std::unique_ptr CustomSpanExporter::MakeRecordable() noexcept +{ + auto recordable = std::make_unique(); + return recordable; +} + +opentelemetry::sdk::common::ExportResult CustomSpanExporter::Export( + const opentelemetry::nostd::span> + & /* spans */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomSpanExporter::Export(): YOUR CODE HERE"); + return opentelemetry::sdk::common::ExportResult::kSuccess; +} + +bool CustomSpanExporter::ForceFlush(std::chrono::microseconds /* timeout */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomSpanExporter::ForceFlush(): YOUR CODE HERE"); + return false; +} + +bool CustomSpanExporter::Shutdown(std::chrono::microseconds /* timeout */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomSpanExporter::Shutdown(): YOUR CODE HERE"); + return false; +} diff --git a/examples/configuration/custom_span_exporter.h b/examples/configuration/custom_span_exporter.h new file mode 100644 index 0000000000..cc8a93b83e --- /dev/null +++ b/examples/configuration/custom_span_exporter.h @@ -0,0 +1,37 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include +#include +#include + +#include "opentelemetry/nostd/span.h" +#include "opentelemetry/sdk/common/exporter_utils.h" +#include "opentelemetry/sdk/trace/exporter.h" +#include "opentelemetry/sdk/trace/recordable.h" + +class CustomSpanExporter : public opentelemetry::sdk::trace::SpanExporter +{ +public: + CustomSpanExporter(const std::string &comment) : comment_(comment) {} + CustomSpanExporter(CustomSpanExporter &&) = delete; + CustomSpanExporter(const CustomSpanExporter &) = delete; + CustomSpanExporter &operator=(CustomSpanExporter &&) = delete; + CustomSpanExporter &operator=(const CustomSpanExporter &other) = delete; + ~CustomSpanExporter() override = default; + + std::unique_ptr MakeRecordable() noexcept override; + + opentelemetry::sdk::common::ExportResult Export( + const opentelemetry::nostd::span> + &spans) noexcept override; + + bool ForceFlush(std::chrono::microseconds timeout) noexcept override; + + bool Shutdown(std::chrono::microseconds timeout) noexcept override; + +private: + std::string comment_; +}; diff --git a/examples/configuration/custom_span_exporter_builder.cc b/examples/configuration/custom_span_exporter_builder.cc new file mode 100644 index 0000000000..cb130f72f3 --- /dev/null +++ b/examples/configuration/custom_span_exporter_builder.cc @@ -0,0 +1,30 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include + +#include "opentelemetry/sdk/configuration/document_node.h" +#include "opentelemetry/sdk/configuration/extension_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/trace/exporter.h" + +#include "custom_span_exporter.h" +#include "custom_span_exporter_builder.h" + +std::unique_ptr CustomSpanExporterBuilder::Build( + const opentelemetry::sdk::configuration::ExtensionSpanExporterConfiguration *model) const +{ + // Read yaml attributes + std::string comment = model->node->GetRequiredString("comment"); + + auto sdk = std::make_unique(comment); + + return sdk; +} + +void CustomSpanExporterBuilder::Register(opentelemetry::sdk::configuration::Registry *registry) +{ + auto builder = std::make_unique(); + registry->SetExtensionSpanExporterBuilder("my_custom_span_exporter", std::move(builder)); +} diff --git a/examples/configuration/custom_span_exporter_builder.h b/examples/configuration/custom_span_exporter_builder.h new file mode 100644 index 0000000000..b562fb02fe --- /dev/null +++ b/examples/configuration/custom_span_exporter_builder.h @@ -0,0 +1,22 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +#include "opentelemetry/sdk/configuration/extension_span_exporter_builder.h" +#include "opentelemetry/sdk/configuration/extension_span_exporter_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/trace/exporter.h" + +class CustomSpanExporterBuilder + : public opentelemetry::sdk::configuration::ExtensionSpanExporterBuilder +{ +public: + static void Register(opentelemetry::sdk::configuration::Registry *registry); + + std::unique_ptr Build( + const opentelemetry::sdk::configuration::ExtensionSpanExporterConfiguration *model) + const override; +}; diff --git a/examples/configuration/custom_span_processor.cc b/examples/configuration/custom_span_processor.cc new file mode 100644 index 0000000000..a73ddf03f3 --- /dev/null +++ b/examples/configuration/custom_span_processor.cc @@ -0,0 +1,44 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include + +#include "opentelemetry/sdk/common/global_log_handler.h" +#include "opentelemetry/sdk/trace/recordable.h" +#include "opentelemetry/sdk/trace/span_data.h" +#include "opentelemetry/trace/span_context.h" + +#include "custom_span_processor.h" + +std::unique_ptr +CustomSpanProcessor::MakeRecordable() noexcept +{ + auto recordable = std::make_unique(); + return recordable; +} + +void CustomSpanProcessor::OnStart( + opentelemetry::sdk::trace::Recordable & /* span */, + const opentelemetry::trace::SpanContext & /* parent_context */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomSpanProcessor::OnStart(): YOUR CODE HERE"); +} + +void CustomSpanProcessor::OnEnd( + std::unique_ptr &&span) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomSpanProcessor::OnEnd(): YOUR CODE HERE"); + auto unused = std::move(span); +} + +bool CustomSpanProcessor::ForceFlush(std::chrono::microseconds /* timeout */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomSpanProcessor::ForceFlush(): YOUR CODE HERE"); + return false; +} + +bool CustomSpanProcessor::Shutdown(std::chrono::microseconds /* timeout */) noexcept +{ + OTEL_INTERNAL_LOG_ERROR("CustomSpanProcessor::Shutdown(): YOUR CODE HERE"); + return false; +} diff --git a/examples/configuration/custom_span_processor.h b/examples/configuration/custom_span_processor.h new file mode 100644 index 0000000000..4da2d6af8f --- /dev/null +++ b/examples/configuration/custom_span_processor.h @@ -0,0 +1,37 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include +#include +#include + +#include "opentelemetry/sdk/trace/processor.h" +#include "opentelemetry/sdk/trace/recordable.h" +#include "opentelemetry/trace/span_context.h" + +class CustomSpanProcessor : public opentelemetry::sdk::trace::SpanProcessor +{ +public: + CustomSpanProcessor(const std::string &comment) : comment_(comment) {} + CustomSpanProcessor(CustomSpanProcessor &&) = delete; + CustomSpanProcessor(const CustomSpanProcessor &) = delete; + CustomSpanProcessor &operator=(CustomSpanProcessor &&) = delete; + CustomSpanProcessor &operator=(const CustomSpanProcessor &other) = delete; + ~CustomSpanProcessor() override = default; + + std::unique_ptr MakeRecordable() noexcept override; + + void OnStart(opentelemetry::sdk::trace::Recordable &span, + const opentelemetry::trace::SpanContext &parent_context) noexcept override; + + void OnEnd(std::unique_ptr &&span) noexcept override; + + bool ForceFlush(std::chrono::microseconds timeout) noexcept override; + + bool Shutdown(std::chrono::microseconds timeout) noexcept override; + +private: + std::string comment_; +}; diff --git a/examples/configuration/custom_span_processor_builder.cc b/examples/configuration/custom_span_processor_builder.cc new file mode 100644 index 0000000000..d7196ea17a --- /dev/null +++ b/examples/configuration/custom_span_processor_builder.cc @@ -0,0 +1,30 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include + +#include "opentelemetry/sdk/configuration/document_node.h" +#include "opentelemetry/sdk/configuration/extension_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/trace/processor.h" + +#include "custom_span_processor.h" +#include "custom_span_processor_builder.h" + +std::unique_ptr CustomSpanProcessorBuilder::Build( + const opentelemetry::sdk::configuration::ExtensionSpanProcessorConfiguration *model) const +{ + // Read yaml attributes + std::string comment = model->node->GetRequiredString("comment"); + + auto sdk = std::make_unique(comment); + + return sdk; +} + +void CustomSpanProcessorBuilder::Register(opentelemetry::sdk::configuration::Registry *registry) +{ + auto builder = std::make_unique(); + registry->SetExtensionSpanProcessorBuilder("my_custom_span_processor", std::move(builder)); +} diff --git a/examples/configuration/custom_span_processor_builder.h b/examples/configuration/custom_span_processor_builder.h new file mode 100644 index 0000000000..bc8fe0e720 --- /dev/null +++ b/examples/configuration/custom_span_processor_builder.h @@ -0,0 +1,22 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +#include "opentelemetry/sdk/configuration/extension_span_processor_builder.h" +#include "opentelemetry/sdk/configuration/extension_span_processor_configuration.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/trace/processor.h" + +class CustomSpanProcessorBuilder + : public opentelemetry::sdk::configuration::ExtensionSpanProcessorBuilder +{ +public: + static void Register(opentelemetry::sdk::configuration::Registry *registry); + + std::unique_ptr Build( + const opentelemetry::sdk::configuration::ExtensionSpanProcessorConfiguration *model) + const override; +}; diff --git a/examples/configuration/extensions.yaml b/examples/configuration/extensions.yaml new file mode 100644 index 0000000000..2ca218d251 --- /dev/null +++ b/examples/configuration/extensions.yaml @@ -0,0 +1,82 @@ +# Copyright The OpenTelemetry Authors +# SPDX-License-Identifier: Apache-2.0 + +# The file format version +file_format: "0.1" + +# Configure if the SDK is disabled or not. This is not required to be provided +# to ensure the SDK isn't disabled, the default value when this is not provided +# is for the SDK to be enabled. +# +# Environment variable: OTEL_SDK_DISABLED +disabled: false + +# Configure text map context propagators. +# +# Environment variable: OTEL_PROPAGATORS +propagator: + # composite: [tracecontext, baggage, b3, b3multi, jaeger, xray, ottrace] + composite: tracecontext + +# Configure tracer provider. +tracer_provider: + # Configure span processors. + processors: + # Configure a batch span processor. + - batch: + # Configure exporter. + # + # Environment variable: OTEL_TRACES_EXPORTER + exporter: + # Configure exporter to be zipkin. + zipkin: + # Configure endpoint. + # + # Environment variable: OTEL_EXPORTER_ZIPKIN_ENDPOINT + endpoint: http://localhost:9411/api/v2/spans + # Configure max time (in milliseconds) to wait for each export. + # + # Environment variable: OTEL_EXPORTER_ZIPKIN_TIMEOUT + timeout: 10000 + # Configure a simple span processor. + - simple: + # Configure exporter. + exporter: + # Configure exporter to be console. + console: {} + - my_custom_span_processor: + comment: "This is a span processor extension point, with properties." + - batch: + exporter: + my_custom_span_exporter: + comment: "This is a span exporter extension point, with properties." + + # Configure the sampler. + sampler: + my_custom_sampler: + comment: "This is a sampler extension point, with properties." + +meter_provider: + readers: + - pull: + exporter: + my_custom_pull_metric_exporter: + comment: "This is a pull metric exporter extension point, with properties." + - periodic: + exporter: + my_custom_push_metric_exporter: + comment: "This is a push metric exporter extension point, with properties." + +logger_provider: + processors: + - simple: + # Configure exporter. + exporter: + # Configure exporter to be console. + console: {} + - my_custom_log_record_processor: + comment: "This is a log record processor extension point, with properties." + - batch: + exporter: + my_custom_log_record_exporter: + comment: "This is a log record exporter extension point, with properties." diff --git a/examples/configuration/kitchen-sink.yaml b/examples/configuration/kitchen-sink.yaml new file mode 100644 index 0000000000..de8d00be68 --- /dev/null +++ b/examples/configuration/kitchen-sink.yaml @@ -0,0 +1,957 @@ +# Copyright The OpenTelemetry Authors +# SPDX-License-Identifier: Apache-2.0 + +# kitchen-sink.yaml demonstrates all configurable surface area, including explanatory comments. +# +# It DOES NOT represent expected real world configuration, as it makes strange configuration +# choices in an effort to exercise the full surface area. +# +# Configuration values are set to their defaults when default values are defined. + +# The file format version. +# The yaml format is documented at +# https://github.com/open-telemetry/opentelemetry-configuration/tree/main/schema +file_format: "1.0-rc.1" +# Configure if the SDK is disabled or not. +# If omitted or null, false is used. +disabled: false +# Configure the log level of the internal logger used by the SDK. +# If omitted, info is used. +log_level: info +# Configure general attribute limits. See also tracer_provider.limits, logger_provider.limits. +attribute_limits: + # Configure max attribute value size. + # Value must be non-negative. + # If omitted or null, there is no limit. + attribute_value_length_limit: 4096 + # Configure max attribute count. + # Value must be non-negative. + # If omitted or null, 128 is used. + attribute_count_limit: 128 +# Configure logger provider. +# If omitted, a noop logger provider is used. +logger_provider: + # Configure log record processors. + processors: + - # Configure a batch log record processor. + batch: + # Configure delay interval (in milliseconds) between two consecutive exports. + # Value must be non-negative. + # If omitted or null, 1000 is used. + schedule_delay: 5000 + # Configure maximum allowed time (in milliseconds) to export data. + # Value must be non-negative. A value of 0 indicates no limit (infinity). + # If omitted or null, 30000 is used. + export_timeout: 30000 + # Configure maximum queue size. Value must be positive. + # If omitted or null, 2048 is used. + max_queue_size: 2048 + # Configure maximum batch size. Value must be positive. + # If omitted or null, 512 is used. + max_export_batch_size: 512 + # Configure exporter. + exporter: + # Configure exporter to be OTLP with HTTP transport. + otlp_http: + endpoint: http://localhost:4318/v1/logs + # Configure certificate used to verify a server's TLS credentials. + # Absolute path to certificate file in PEM format. + # If omitted or null, system default certificate verification is used for secure connections. + certificate_file: /app/cert.pem + # Configure mTLS private client key. + # Absolute path to client key file in PEM format. If set, .client_certificate must also be set. + # If omitted or null, mTLS is not used. + client_key_file: /app/cert.pem + # Configure mTLS client certificate. + # Absolute path to client certificate file in PEM format. If set, .client_key must also be set. + # If omitted or null, mTLS is not used. + client_certificate_file: /app/cert.pem + # Configure headers. Entries have higher priority than entries from .headers_list. + # If an entry's .value is null, the entry is ignored. + headers: + - name: api-key + value: "1234" + # Configure headers. Entries have lower priority than entries from .headers. + # The value is a list of comma separated key-value pairs matching the format of OTEL_EXPORTER_OTLP_HEADERS. See https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md#configuration-options for details. + # If omitted or null, no headers are added. + headers_list: "api-key=1234" + # Configure compression. + # Values include: gzip, none. Implementations may support other compression algorithms. + # If omitted or null, none is used. + compression: gzip + # Configure max time (in milliseconds) to wait for each export. + # Value must be non-negative. A value of 0 indicates no limit (infinity). + # If omitted or null, 10000 is used. + timeout: 10000 + # Configure the encoding used for messages. + # Values include: protobuf, json. Implementations may not support json. + # If omitted or null, protobuf is used. + encoding: protobuf + - # Configure a batch log record processor. + batch: + # Configure exporter. + exporter: + # Configure exporter to be OTLP with gRPC transport. + otlp_grpc: + # Configure endpoint. + # If omitted or null, http://localhost:4317 is used. + endpoint: http://localhost:4317 + # Configure certificate used to verify a server's TLS credentials. + # Absolute path to certificate file in PEM format. + # If omitted or null, system default certificate verification is used for secure connections. + certificate_file: /app/cert.pem + # Configure mTLS private client key. + # Absolute path to client key file in PEM format. If set, .client_certificate must also be set. + # If omitted or null, mTLS is not used. + client_key_file: /app/cert.pem + # Configure mTLS client certificate. + # Absolute path to client certificate file in PEM format. If set, .client_key must also be set. + # If omitted or null, mTLS is not used. + client_certificate_file: /app/cert.pem + # Configure headers. Entries have higher priority than entries from .headers_list. + # If an entry's .value is null, the entry is ignored. + headers: + - name: api-key + value: "1234" + # Configure headers. Entries have lower priority than entries from .headers. + # The value is a list of comma separated key-value pairs matching the format of OTEL_EXPORTER_OTLP_HEADERS. See https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md#configuration-options for details. + # If omitted or null, no headers are added. + headers_list: "api-key=1234" + # Configure compression. + # Values include: gzip, none. Implementations may support other compression algorithms. + # If omitted or null, none is used. + compression: gzip + # Configure max time (in milliseconds) to wait for each export. + # Value must be non-negative. A value of 0 indicates no limit (infinity). + # If omitted or null, 10000 is used. + timeout: 10000 + # Configure client transport security for the exporter's connection. + # Only applicable when .endpoint is provided without http or https scheme. Implementations may choose to ignore .insecure. + # If omitted or null, false is used. + insecure: false + - # Configure a batch log record processor. + batch: + # Configure exporter. + exporter: + # Configure exporter to be OTLP with file transport. + # This type is in development and subject to breaking changes in minor versions. + otlp_file/development: + # Configure output stream. + # Values include stdout, or scheme+destination. For example: file:///path/to/file.jsonl. + # If omitted or null, stdout is used. + output_stream: file:///var/log/logs.jsonl + - # Configure a batch log record processor. + batch: + # Configure exporter. + exporter: + # Configure exporter to be OTLP with file transport. + # This type is in development and subject to breaking changes in minor versions. + otlp_file/development: + # Configure output stream. + # Values include stdout, or scheme+destination. For example: file:///path/to/file.jsonl. + # If omitted or null, stdout is used. + output_stream: stdout + - # Configure a simple log record processor. + simple: + # Configure exporter. + exporter: + # Configure exporter to be console. + console: + # Configure log record limits. See also attribute_limits. + limits: + # Configure max attribute value size. Overrides .attribute_limits.attribute_value_length_limit. + # Value must be non-negative. + # If omitted or null, there is no limit. + attribute_value_length_limit: 4096 + # Configure max attribute count. Overrides .attribute_limits.attribute_count_limit. + # Value must be non-negative. + # If omitted or null, 128 is used. + attribute_count_limit: 128 + # Configure loggers. + # This type is in development and subject to breaking changes in minor versions. + logger_configurator/development: + # Configure the default logger config used there is no matching entry in .logger_configurator/development.loggers. + default_config: + # Configure if the logger is enabled or not. + disabled: true + # Configure loggers. + loggers: + - # Configure logger names to match, evaluated as follows: + # + # * If the logger name exactly matches. + # * If the logger name matches the wildcard pattern, where '?' matches any single character and '*' matches any number of characters including none. + name: io.opentelemetry.contrib.* + # The logger config. + config: + # Configure if the logger is enabled or not. + disabled: false +# Configure meter provider. +# If omitted, a noop meter provider is used. +meter_provider: + # Configure metric readers. + readers: + - # Configure a pull based metric reader. + pull: + # Configure exporter. + exporter: + # Configure exporter to be prometheus. + # This type is in development and subject to breaking changes in minor versions. + prometheus/development: + # Configure host. + # If omitted or null, localhost is used. + host: localhost + # Configure port. + # If omitted or null, 9464 is used. + port: 9464 + # Configure Prometheus Exporter to produce metrics without a unit suffix or UNIT metadata. + # If omitted or null, false is used. + without_units: false + # Configure Prometheus Exporter to produce metrics without a type suffix. + # If omitted or null, false is used. + without_type_suffix: false + # Configure Prometheus Exporter to produce metrics without a scope info metric. + # If omitted or null, false is used. + without_scope_info: false + # Configure Prometheus Exporter to add resource attributes as metrics attributes. + with_resource_constant_labels: + # Configure resource attributes to be included. + # Attribute keys from resources are evaluated to match as follows: + # * If the value of the attribute key exactly matches. + # * If the value of the attribute key matches the wildcard pattern, where '?' matches any single character and '*' matches any number of characters including none. + # If omitted, no resource attributes are included. + included: + - "service*" + # Configure resource attributes to be excluded. Applies after .with_resource_constant_labels.included (i.e. excluded has higher priority than included). + # Attribute keys from resources are evaluated to match as follows: + # * If the value of the attribute key exactly matches. + # * If the value of the attribute key matches the wildcard pattern, where '?' matches any single character and '*' matches any number of characters including none. + # If omitted, .included resource attributes are included. + excluded: + - "service.attr1" + # Configure metric producers. + producers: + - # Configure metric producer to be opencensus. + opencensus: + # Configure cardinality limits. + cardinality_limits: + # Configure default cardinality limit for all instrument types. + # Instrument-specific cardinality limits take priority. + # If omitted or null, 2000 is used. + default: 2000 + # Configure default cardinality limit for counter instruments. + # If omitted or null, the value from .default is used. + counter: 2000 + # Configure default cardinality limit for gauge instruments. + # If omitted or null, the value from .default is used. + gauge: 2000 + # Configure default cardinality limit for histogram instruments. + # If omitted or null, the value from .default is used. + histogram: 2000 + # Configure default cardinality limit for observable_counter instruments. + # If omitted or null, the value from .default is used. + observable_counter: 2000 + # Configure default cardinality limit for observable_gauge instruments. + # If omitted or null, the value from .default is used. + observable_gauge: 2000 + # Configure default cardinality limit for observable_up_down_counter instruments. + # If omitted or null, the value from .default is used. + observable_up_down_counter: 2000 + # Configure default cardinality limit for up_down_counter instruments. + # If omitted or null, the value from .default is used. + up_down_counter: 2000 + - # Configure a periodic metric reader. + periodic: + # Configure delay interval (in milliseconds) between start of two consecutive exports. + # Value must be non-negative. + # If omitted or null, 60000 is used. + interval: 60000 + # Configure maximum allowed time (in milliseconds) to export data. + # Value must be non-negative. A value of 0 indicates no limit (infinity). + # If omitted or null, 30000 is used. + timeout: 30000 + # Configure exporter. + exporter: + # Configure exporter to be OTLP with HTTP transport. + otlp_http: + # Configure endpoint, including the metric specific path. + # If omitted or null, http://localhost:4318/v1/metrics is used. + endpoint: http://localhost:4318/v1/metrics + # Configure certificate used to verify a server's TLS credentials. + # Absolute path to certificate file in PEM format. + # If omitted or null, system default certificate verification is used for secure connections. + certificate_file: /app/cert.pem + # Configure mTLS private client key. + # Absolute path to client key file in PEM format. If set, .client_certificate must also be set. + # If omitted or null, mTLS is not used. + client_key_file: /app/cert.pem + # Configure mTLS client certificate. + # Absolute path to client certificate file in PEM format. If set, .client_key must also be set. + # If omitted or null, mTLS is not used. + client_certificate_file: /app/cert.pem + # Configure headers. Entries have higher priority than entries from .headers_list. + # If an entry's .value is null, the entry is ignored. + headers: + - name: api-key + value: "1234" + # Configure headers. Entries have lower priority than entries from .headers. + # The value is a list of comma separated key-value pairs matching the format of OTEL_EXPORTER_OTLP_HEADERS. See https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md#configuration-options for details. + # If omitted or null, no headers are added. + headers_list: "api-key=1234" + # Configure compression. + # Values include: gzip, none. Implementations may support other compression algorithms. + # If omitted or null, none is used. + compression: gzip + # Configure max time (in milliseconds) to wait for each export. + # Value must be non-negative. A value of 0 indicates no limit (infinity). + # If omitted or null, 10000 is used. + timeout: 10000 + # Configure the encoding used for messages. + # Values include: protobuf, json. Implementations may not support json. + # If omitted or null, protobuf is used. + encoding: protobuf + # Configure temporality preference. + # Values include: cumulative, delta, low_memory. For behavior of values, see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk_exporters/otlp.md. + # If omitted or null, cumulative is used. + temporality_preference: delta + # Configure default histogram aggregation. + # Values include: explicit_bucket_histogram, base2_exponential_bucket_histogram. For behavior of values, see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk_exporters/otlp.md. + # If omitted or null, explicit_bucket_histogram is used. + default_histogram_aggregation: base2_exponential_bucket_histogram + # Configure metric producers. + producers: + - # Configure metric producer to be prometheus. + prometheus: + # Configure cardinality limits. + cardinality_limits: + # Configure default cardinality limit for all instrument types. + # Instrument-specific cardinality limits take priority. + # If omitted or null, 2000 is used. + default: 2000 + # Configure default cardinality limit for counter instruments. + # If omitted or null, the value from .default is used. + counter: 2000 + # Configure default cardinality limit for gauge instruments. + # If omitted or null, the value from .default is used. + gauge: 2000 + # Configure default cardinality limit for histogram instruments. + # If omitted or null, the value from .default is used. + histogram: 2000 + # Configure default cardinality limit for observable_counter instruments. + # If omitted or null, the value from .default is used. + observable_counter: 2000 + # Configure default cardinality limit for observable_gauge instruments. + # If omitted or null, the value from .default is used. + observable_gauge: 2000 + # Configure default cardinality limit for observable_up_down_counter instruments. + # If omitted or null, the value from .default is used. + observable_up_down_counter: 2000 + # Configure default cardinality limit for up_down_counter instruments. + # If omitted or null, the value from .default is used. + up_down_counter: 2000 + - # Configure a periodic metric reader. + periodic: + # Configure exporter. + exporter: + # Configure exporter to be OTLP with gRPC transport. + otlp_grpc: + # Configure endpoint. + # If omitted or null, http://localhost:4317 is used. + endpoint: http://localhost:4317 + # Configure certificate used to verify a server's TLS credentials. + # Absolute path to certificate file in PEM format. + # If omitted or null, system default certificate verification is used for secure connections. + certificate_file: /app/cert.pem + # Configure mTLS private client key. + # Absolute path to client key file in PEM format. If set, .client_certificate must also be set. + # If omitted or null, mTLS is not used. + client_key_file: /app/cert.pem + # Configure mTLS client certificate. + # Absolute path to client certificate file in PEM format. If set, .client_key must also be set. + # If omitted or null, mTLS is not used. + client_certificate_file: /app/cert.pem + # Configure headers. Entries have higher priority than entries from .headers_list. + # If an entry's .value is null, the entry is ignored. + headers: + - name: api-key + value: "1234" + # Configure headers. Entries have lower priority than entries from .headers. + # The value is a list of comma separated key-value pairs matching the format of OTEL_EXPORTER_OTLP_HEADERS. See https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md#configuration-options for details. + # If omitted or null, no headers are added. + headers_list: "api-key=1234" + # Configure compression. + # Values include: gzip, none. Implementations may support other compression algorithms. + # If omitted or null, none is used. + compression: gzip + # Configure max time (in milliseconds) to wait for each export. + # Value must be non-negative. A value of 0 indicates no limit (infinity). + # If omitted or null, 10000 is used. + timeout: 10000 + # Configure client transport security for the exporter's connection. + # Only applicable when .endpoint is provided without http or https scheme. Implementations may choose to ignore .insecure. + # If omitted or null, false is used. + insecure: false + # Configure temporality preference. + # Values include: cumulative, delta, low_memory. For behavior of values, see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk_exporters/otlp.md. + # If omitted or null, cumulative is used. + temporality_preference: delta + # Configure default histogram aggregation. + # Values include: explicit_bucket_histogram, base2_exponential_bucket_histogram. For behavior of values, see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk_exporters/otlp.md. + # If omitted or null, explicit_bucket_histogram is used. + default_histogram_aggregation: base2_exponential_bucket_histogram + - # Configure a periodic metric reader. + periodic: + # Configure exporter. + exporter: + # Configure exporter to be OTLP with file transport. + # This type is in development and subject to breaking changes in minor versions. + otlp_file/development: + # Configure output stream. + # Values include stdout, or scheme+destination. For example: file:///path/to/file.jsonl. + # If omitted or null, stdout is used. + output_stream: file:///var/log/metrics.jsonl + # Configure temporality preference. Values include: cumulative, delta, low_memory. For behavior of values, see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk_exporters/otlp.md. + # If omitted or null, cumulative is used. + temporality_preference: delta + # Configure default histogram aggregation. Values include: explicit_bucket_histogram, base2_exponential_bucket_histogram. For behavior of values, see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk_exporters/otlp.md. + # If omitted or null, explicit_bucket_histogram is used. + default_histogram_aggregation: base2_exponential_bucket_histogram + - # Configure a periodic metric reader. + periodic: + # Configure exporter. + exporter: + # Configure exporter to be OTLP with file transport. + # This type is in development and subject to breaking changes in minor versions. + otlp_file/development: + # Configure output stream. + # Values include stdout, or scheme+destination. For example: file:///path/to/file.jsonl. + # If omitted or null, stdout is used. + output_stream: stdout + # Configure temporality preference. Values include: cumulative, delta, low_memory. For behavior of values, see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk_exporters/otlp.md. + # If omitted or null, cumulative is used. + temporality_preference: delta + # Configure default histogram aggregation. Values include: explicit_bucket_histogram, base2_exponential_bucket_histogram. For behavior of values, see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk_exporters/otlp.md. + # If omitted or null, explicit_bucket_histogram is used. + default_histogram_aggregation: base2_exponential_bucket_histogram + - # Configure a periodic metric reader. + periodic: + # Configure exporter. + exporter: + # Configure exporter to be console. + console: + # Configure views. + # Each view has a selector which determines the instrument(s) it applies to, and a configuration for the resulting stream(s). + views: + - # Configure view selector. + # Selection criteria is additive as described in https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#instrument-selection-criteria. + selector: + # Configure instrument name selection criteria. + # If omitted or null, all instrument names match. + instrument_name: my-instrument + # Configure instrument type selection criteria. + # Values include: counter, gauge, histogram, observable_counter, observable_gauge, observable_up_down_counter, up_down_counter. + # If omitted or null, all instrument types match. + instrument_type: histogram + # Configure the instrument unit selection criteria. + # If omitted or null, all instrument units match. + unit: ms + # Configure meter name selection criteria. + # If omitted or null, all meter names match. + meter_name: my-meter + # Configure meter version selection criteria. + # If omitted or null, all meter versions match. + meter_version: 1.0.0 + # Configure meter schema url selection criteria. + # If omitted or null, all meter schema URLs match. + meter_schema_url: https://opentelemetry.io/schemas/1.16.0 + # Configure view stream. + stream: + # Configure metric name of the resulting stream(s). + # If omitted or null, the instrument's original name is used. + name: new_instrument_name + # Configure metric description of the resulting stream(s). + # If omitted or null, the instrument's origin description is used. + description: new_description + # Configure aggregation of the resulting stream(s). + # Values include: default, drop, explicit_bucket_histogram, base2_exponential_bucket_histogram, last_value, sum. For behavior of values see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#aggregation. + # If omitted, default is used. + aggregation: + # Configure aggregation to be explicit_bucket_histogram. + explicit_bucket_histogram: + # Configure bucket boundaries. + # If omitted, [0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000] is used. + boundaries: + [ + 0.0, + 5.0, + 10.0, + 25.0, + 50.0, + 75.0, + 100.0, + 250.0, + 500.0, + 750.0, + 1000.0, + 2500.0, + 5000.0, + 7500.0, + 10000.0 + ] + # Configure record min and max. + # If omitted or null, true is used. + record_min_max: true + # Configure the aggregation cardinality limit. + # If omitted or null, the metric reader's default cardinality limit is used. + aggregation_cardinality_limit: 2000 + # Configure attribute keys retained in the resulting stream(s). + attribute_keys: + # Configure list of attribute keys to include in the resulting stream(s). All other attributes are dropped. + # If omitted, all attributes are included. + included: + - key1 + - key2 + # Configure list of attribute keys to exclude from the resulting stream(s). Applies after .attribute_keys.included (i.e. excluded has higher priority than included). + # If omitted, .attribute_keys.included are included. + excluded: + - key3 + # Configure the exemplar filter. + # Values include: trace_based, always_on, always_off. For behavior of values see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/configuration/sdk-environment-variables.md#metrics-sdk-configuration. + # If omitted or null, trace_based is used. + exemplar_filter: trace_based + # Configure meters. + # This type is in development and subject to breaking changes in minor versions. + meter_configurator/development: + # Configure the default meter config used there is no matching entry in .meter_configurator/development.meters. + default_config: + # Configure if the meter is enabled or not. + disabled: true + # Configure meters. + meters: + - # Configure meter names to match, evaluated as follows: + # + # * If the meter name exactly matches. + # * If the meter name matches the wildcard pattern, where '?' matches any single character and '*' matches any number of characters including none. + name: io.opentelemetry.contrib.* + # The meter config. + config: + # Configure if the meter is enabled or not. + disabled: false +# Configure text map context propagators. +# If omitted, a noop propagator is used. +propagator: + # Configure the propagators in the composite text map propagator. Entries from .composite_list are appended to the list here with duplicates filtered out. + # Built-in propagator keys include: tracecontext, baggage, b3, b3multi, jaeger, ottrace. Known third party keys include: xray. + # If the resolved list of propagators (from .composite and .composite_list) is empty, a noop propagator is used. + composite: + - # Include the w3c trace context propagator. + tracecontext: + - # Include the w3c baggage propagator. + baggage: + - # Include the zipkin b3 propagator. + b3: + - # Include the zipkin b3 multi propagator. + b3multi: + - # Include the jaeger propagator. + jaeger: + +# ottrace not supported in opentelemetry-cpp +# - # Include the opentracing propagator. +# ottrace: + + # Configure the propagators in the composite text map propagator. Entries are appended to .composite with duplicates filtered out. + # The value is a comma separated list of propagator identifiers matching the format of OTEL_PROPAGATORS. See https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/configuration/sdk-environment-variables.md#general-sdk-configuration for details. + # Built-in propagator identifiers include: tracecontext, baggage, b3, b3multi, jaeger, ottrace. Known third party identifiers include: xray. + # If the resolved list of propagators (from .composite and .composite_list) is empty, a noop propagator is used. +# composite_list: "tracecontext,baggage,b3,b3multi,jaeger,ottrace,xray" + +# ottrace, xray not supported in opentelemetry-cpp + composite_list: "tracecontext,baggage,b3,b3multi,jaeger" + +# Configure tracer provider. +# If omitted, a noop tracer provider is used. +tracer_provider: + # Configure span processors. + processors: + - # Configure a batch span processor. + batch: + # Configure delay interval (in milliseconds) between two consecutive exports. + # Value must be non-negative. + # If omitted or null, 5000 is used. + schedule_delay: 5000 + # Configure maximum allowed time (in milliseconds) to export data. + # Value must be non-negative. A value of 0 indicates no limit (infinity). + # If omitted or null, 30000 is used. + export_timeout: 30000 + # Configure maximum queue size. Value must be positive. + # If omitted or null, 2048 is used. + max_queue_size: 2048 + # Configure maximum batch size. Value must be positive. + # If omitted or null, 512 is used. + max_export_batch_size: 512 + # Configure exporter. + exporter: + # Configure exporter to be OTLP with HTTP transport. + otlp_http: + # Configure endpoint, including the trace specific path. + # If omitted or null, http://localhost:4318/v1/traces is used. + endpoint: http://localhost:4318/v1/traces + # Configure certificate used to verify a server's TLS credentials. + # Absolute path to certificate file in PEM format. + # If omitted or null, system default certificate verification is used for secure connections. + certificate_file: /app/cert.pem + # Configure mTLS private client key. + # Absolute path to client key file in PEM format. If set, .client_certificate must also be set. + # If omitted or null, mTLS is not used. + client_key_file: /app/cert.pem + # Configure mTLS client certificate. + # Absolute path to client certificate file in PEM format. If set, .client_key must also be set. + # If omitted or null, mTLS is not used. + client_certificate_file: /app/cert.pem + # Configure headers. Entries have higher priority than entries from .headers_list. + # If an entry's .value is null, the entry is ignored. + headers: + - name: api-key + value: "1234" + # Configure headers. Entries have lower priority than entries from .headers. + # The value is a list of comma separated key-value pairs matching the format of OTEL_EXPORTER_OTLP_HEADERS. See https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md#configuration-options for details. + # If omitted or null, no headers are added. + headers_list: "api-key=1234" + # Configure compression. + # Values include: gzip, none. Implementations may support other compression algorithms. + # If omitted or null, none is used. + compression: gzip + # Configure max time (in milliseconds) to wait for each export. + # Value must be non-negative. A value of 0 indicates no limit (infinity). + # If omitted or null, 10000 is used. + timeout: 10000 + # Configure the encoding used for messages. + # Values include: protobuf, json. Implementations may not support json. + # If omitted or null, protobuf is used. + encoding: protobuf + - # Configure a batch span processor. + batch: + # Configure exporter. + exporter: + # Configure exporter to be OTLP with gRPC transport. + otlp_grpc: + # Configure endpoint. + # If omitted or null, http://localhost:4317 is used. + endpoint: http://localhost:4317 + # Configure certificate used to verify a server's TLS credentials. + # Absolute path to certificate file in PEM format. + # If omitted or null, system default certificate verification is used for secure connections. + certificate_file: /app/cert.pem + # Configure mTLS private client key. + # Absolute path to client key file in PEM format. If set, .client_certificate must also be set. + # If omitted or null, mTLS is not used. + client_key_file: /app/cert.pem + # Configure mTLS client certificate. + # Absolute path to client certificate file in PEM format. If set, .client_key must also be set. + # If omitted or null, mTLS is not used. + client_certificate_file: /app/cert.pem + # Configure headers. Entries have higher priority than entries from .headers_list. + # If an entry's .value is null, the entry is ignored. + headers: + - name: api-key + value: "1234" + # Configure headers. Entries have lower priority than entries from .headers. + # The value is a list of comma separated key-value pairs matching the format of OTEL_EXPORTER_OTLP_HEADERS. See https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md#configuration-options for details. + # If omitted or null, no headers are added. + headers_list: "api-key=1234" + # Configure compression. + # Values include: gzip, none. Implementations may support other compression algorithms. + # If omitted or null, none is used. + compression: gzip + # Configure max time (in milliseconds) to wait for each export. + # Value must be non-negative. A value of 0 indicates no limit (infinity). + # If omitted or null, 10000 is used. + timeout: 10000 + # Configure client transport security for the exporter's connection. + # Only applicable when .endpoint is provided without http or https scheme. Implementations may choose to ignore .insecure. + # If omitted or null, false is used. + insecure: false + - # Configure a batch span processor. + batch: + # Configure exporter. + exporter: + # Configure exporter to be OTLP with file transport. + # This type is in development and subject to breaking changes in minor versions. + otlp_file/development: + # Configure output stream. + # Values include stdout, or scheme+destination. For example: file:///path/to/file.jsonl. + # If omitted or null, stdout is used. + output_stream: file:///var/log/traces.jsonl + - # Configure a batch span processor. + batch: + # Configure exporter. + exporter: + # Configure exporter to be OTLP with file transport. + # This type is in development and subject to breaking changes in minor versions. + otlp_file/development: + # Configure output stream. + # Values include stdout, or scheme+destination. For example: file:///path/to/file.jsonl. + # If omitted or null, stdout is used. + output_stream: stdout + - # Configure a batch span processor. + batch: + # Configure exporter. + exporter: + # Configure exporter to be zipkin. + zipkin: + # Configure endpoint. + # If omitted or null, http://localhost:9411/api/v2/spans is used. + endpoint: http://localhost:9411/api/v2/spans + # Configure max time (in milliseconds) to wait for each export. + # Value must be non-negative. A value of 0 indicates indefinite. + # If omitted or null, 10000 is used. + timeout: 10000 + - # Configure a simple span processor. + simple: + # Configure exporter. + exporter: + # Configure exporter to be console. + console: + # Configure span limits. See also attribute_limits. + limits: + # Configure max attribute value size. Overrides .attribute_limits.attribute_value_length_limit. + # Value must be non-negative. + # If omitted or null, there is no limit. + attribute_value_length_limit: 4096 + # Configure max attribute count. Overrides .attribute_limits.attribute_count_limit. + # Value must be non-negative. + # If omitted or null, 128 is used. + attribute_count_limit: 128 + # Configure max span event count. + # Value must be non-negative. + # If omitted or null, 128 is used. + event_count_limit: 128 + # Configure max span link count. + # Value must be non-negative. + # If omitted or null, 128 is used. + link_count_limit: 128 + # Configure max attributes per span event. + # Value must be non-negative. + # If omitted or null, 128 is used. + event_attribute_count_limit: 128 + # Configure max attributes per span link. + # Value must be non-negative. + # If omitted or null, 128 is used. + link_attribute_count_limit: 128 + # Configure the sampler. + # If omitted, parent based sampler with a root of always_on is used. + sampler: + # Configure sampler to be parent_based. + parent_based: + # Configure root sampler. + # If omitted or null, always_on is used. + root: + # Configure sampler to be trace_id_ratio_based. + trace_id_ratio_based: + # Configure trace_id_ratio. + # If omitted or null, 1.0 is used. + ratio: 0.0001 + # Configure remote_parent_sampled sampler. + # If omitted or null, always_on is used. + remote_parent_sampled: + # Configure sampler to be always_on. + always_on: + # Configure remote_parent_not_sampled sampler. + # If omitted or null, always_off is used. + remote_parent_not_sampled: + # Configure sampler to be always_off. + always_off: + # Configure local_parent_sampled sampler. + # If omitted or null, always_on is used. + local_parent_sampled: + # Configure sampler to be always_on. + always_on: + # Configure local_parent_not_sampled sampler. + # If omitted or null, always_off is used. + local_parent_not_sampled: + # Configure sampler to be always_off. + always_off: + # Configure tracers. + # This type is in development and subject to breaking changes in minor versions. + tracer_configurator/development: + # Configure the default tracer config used there is no matching entry in .tracer_configurator/development.tracers. + default_config: + # Configure if the tracer is enabled or not. + disabled: true + # Configure tracers. + tracers: + - # Configure tracer names to match, evaluated as follows: + # + # * If the tracer name exactly matches. + # * If the tracer name matches the wildcard pattern, where '?' matches any single character and '*' matches any number of characters including none. + name: io.opentelemetry.contrib.* + # The tracer config. + config: + # Configure if the tracer is enabled or not. + disabled: false +# Configure resource for all signals. +# If omitted, the default resource is used. +resource: + # Configure resource attributes. Entries have higher priority than entries from .resource.attributes_list. + # Entries must contain .name and .value, and may optionally include .type. If an entry's .type omitted or null, string is used. + # The .value's type must match the .type. Values for .type include: string, bool, int, double, string_array, bool_array, int_array, double_array. + attributes: + - name: service.name + value: unknown_service + - name: string_key + value: value + type: string + - name: bool_key + value: true + type: bool + - name: int_key + value: 1 + type: int + - name: double_key + value: 1.1 + type: double + - name: string_array_key + value: [ "value1", "value2" ] + type: string_array + - name: bool_array_key + value: [ true, false ] + type: bool_array + - name: int_array_key + value: [ 1, 2 ] + type: int_array + - name: double_array_key + value: [ 1.1, 2.2 ] + type: double_array + # Configure resource attributes. Entries have lower priority than entries from .resource.attributes. + # The value is a list of comma separated key-value pairs matching the format of OTEL_RESOURCE_ATTRIBUTES. See https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/configuration/sdk-environment-variables.md#general-sdk-configuration for details. + # If omitted or null, no resource attributes are added. + attributes_list: "service.namespace=my-namespace,service.version=1.0.0" + # Configure resource detection. + # This type is in development and subject to breaking changes in minor versions. + # If omitted or null, resource detection is disabled. + detection/development: + # Configure attributes provided by resource detectors. + attributes: + # Configure list of attribute key patterns to include from resource detectors. + # Attribute keys from resource detectors are evaluated to match as follows: + # * If the value of the attribute key exactly matches. + # * If the value of the attribute key matches the wildcard pattern, where '?' matches any single character and '*' matches any number of characters including none. + # If omitted, all attributes are included. + included: + - process.* + # Configure list of attribute key patterns to exclude from resource detectors. Applies after .resource.detectors.attributes.included (i.e. excluded has higher priority than included). + # Attribute keys from resource detectors are evaluated to match as follows: + # * If the value of the attribute key exactly matches. + # * If the value of the attribute key matches the wildcard pattern, where '?' matches any single character and '*' matches any number of characters including none. + # If omitted, .included attributes are included. + excluded: + - process.command_args + # Configure resource detectors. + # Resource detector names are dependent on the SDK language ecosystem. Please consult documentation for each respective language. + # If omitted or null, no resource detectors are enabled. + detectors: + - # Enable the container resource detector, which populates container.* attributes. + container: + - # Enable the host resource detector, which populates host.* and os.* attributes. + host: + - # Enable the process resource detector, which populates process.* attributes. + process: + - # Enable the service detector, which populates service.name based on the OTEL_SERVICE_NAME environment variable and service.instance.id. + service: + # Configure resource schema URL. + # If omitted or null, no schema URL is used. + schema_url: https://opentelemetry.io/schemas/1.16.0 +# Configure instrumentation. +# This type is in development and subject to breaking changes in minor versions. +instrumentation/development: + # Configure general SemConv options that may apply to multiple languages and instrumentations. + # Instrumenation may merge general config options with the language specific configuration at .instrumentation.. + general: + # Configure instrumentations following the peer semantic conventions. + # See peer semantic conventions: https://opentelemetry.io/docs/specs/semconv/attributes-registry/peer/ + peer: + # Configure the service mapping for instrumentations following peer.service semantic conventions. + # Each entry is a key value pair where "peer" defines the IP address and "service" defines the corresponding logical name of the service. + # See peer.service semantic conventions: https://opentelemetry.io/docs/specs/semconv/general/attributes/#general-remote-service-attributes + service_mapping: + - peer: 1.2.3.4 + service: FooService + - peer: 2.3.4.5 + service: BarService + # Configure instrumentations following the http semantic conventions. + # See http semantic conventions: https://opentelemetry.io/docs/specs/semconv/http/ + http: + # Configure instrumentations following the http client semantic conventions. + client: + # Configure headers to capture for outbound http requests. + request_captured_headers: + - Content-Type + - Accept + # Configure headers to capture for outbound http responses. + response_captured_headers: + - Content-Type + - Content-Encoding + # Configure instrumentations following the http server semantic conventions. + server: + # Configure headers to capture for inbound http requests. + request_captured_headers: + - Content-Type + - Accept + # Configure headers to capture for outbound http responses. + response_captured_headers: + - Content-Type + - Content-Encoding + # Configure C++ language-specific instrumentation libraries. + cpp: + # Configure the instrumentation corresponding to key "example". + example: + property: "value" + # Configure .NET language-specific instrumentation libraries. + dotnet: + # Configure the instrumentation corresponding to key "example". + example: + property: "value" + # Configure Erlang language-specific instrumentation libraries. + erlang: + # Configure the instrumentation corresponding to key "example". + example: + property: "value" + # Configure Go language-specific instrumentation libraries. + go: + # Configure the instrumentation corresponding to key "example". + example: + property: "value" + # Configure Java language-specific instrumentation libraries. + java: + # Configure the instrumentation corresponding to key "example". + example: + property: "value" + # Configure JavaScript language-specific instrumentation libraries. + js: + # Configure the instrumentation corresponding to key "example". + example: + property: "value" + # Configure PHP language-specific instrumentation libraries. + php: + # Configure the instrumentation corresponding to key "example". + example: + property: "value" + # Configure Python language-specific instrumentation libraries. + python: + # Configure the instrumentation corresponding to key "example". + example: + property: "value" + # Configure Ruby language-specific instrumentation libraries. + ruby: + # Configure the instrumentation corresponding to key "example". + example: + property: "value" + # Configure Rust language-specific instrumentation libraries. + rust: + # Configure the instrumentation corresponding to key "example". + example: + property: "value" + # Configure Swift language-specific instrumentation libraries. + swift: + # Configure the instrumentation corresponding to key "example". + example: + property: "value" diff --git a/examples/configuration/main.cc b/examples/configuration/main.cc new file mode 100644 index 0000000000..f6abd6c979 --- /dev/null +++ b/examples/configuration/main.cc @@ -0,0 +1,394 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include + +#include "opentelemetry/exporters/ostream/console_log_record_builder.h" +#include "opentelemetry/exporters/ostream/console_push_metric_builder.h" +#include "opentelemetry/exporters/ostream/console_span_builder.h" +#include "opentelemetry/nostd/shared_ptr.h" +#include "opentelemetry/sdk/common/attribute_utils.h" +#include "opentelemetry/sdk/common/global_log_handler.h" +#include "opentelemetry/sdk/configuration/configuration.h" +#include "opentelemetry/sdk/configuration/configured_sdk.h" +#include "opentelemetry/sdk/configuration/registry.h" +#include "opentelemetry/sdk/configuration/yaml_configuration_parser.h" + +#include "custom_log_record_exporter_builder.h" +#include "custom_log_record_processor_builder.h" +#include "custom_pull_metric_exporter_builder.h" +#include "custom_push_metric_exporter_builder.h" +#include "custom_sampler_builder.h" +#include "custom_span_exporter_builder.h" +#include "custom_span_processor_builder.h" + +#ifdef BAZEL_BUILD +# include "examples/common/logs_foo_library/foo_library.h" +# include "examples/common/metrics_foo_library/foo_library.h" +#else +# include "logs_foo_library/foo_library.h" +# include "metrics_foo_library/foo_library.h" +#endif + +#ifdef OTEL_HAVE_OTLP_HTTP +# include "opentelemetry/exporters/otlp/otlp_http_log_record_builder.h" +# include "opentelemetry/exporters/otlp/otlp_http_push_metric_builder.h" +# include "opentelemetry/exporters/otlp/otlp_http_span_builder.h" +#endif + +#ifdef OTEL_HAVE_OTLP_GRPC +# include "opentelemetry/exporters/otlp/otlp_grpc_log_record_builder.h" +# include "opentelemetry/exporters/otlp/otlp_grpc_push_metric_builder.h" +# include "opentelemetry/exporters/otlp/otlp_grpc_span_builder.h" +#endif + +#ifdef OTEL_HAVE_OTLP_FILE +# include "opentelemetry/exporters/otlp/otlp_file_log_record_builder.h" +# include "opentelemetry/exporters/otlp/otlp_file_push_metric_builder.h" +# include "opentelemetry/exporters/otlp/otlp_file_span_builder.h" +#endif + +#ifdef OTEL_HAVE_ZIPKIN +# include "opentelemetry/exporters/zipkin/zipkin_builder.h" +#endif + +#ifdef OTEL_HAVE_PROMETHEUS +# include "opentelemetry/exporters/prometheus/prometheus_pull_builder.h" +#endif + +static bool opt_help = false; +static bool opt_debug = false; +static bool opt_test = false; +static bool opt_no_registry = false; +static std::string yaml_file_path = ""; + +static std::unique_ptr sdk; + +namespace +{ + +class CheckerLogHandler : public opentelemetry::sdk::common::internal_log::LogHandler +{ +public: + void Handle(opentelemetry::sdk::common::internal_log::LogLevel level, + const char * /* file */, + int /* line */, + const char *msg, + const opentelemetry::sdk::common::AttributeMap & /* attributes */) noexcept override + { + if (msg == nullptr) + { + msg = ""; + } + switch (level) + { + case opentelemetry::sdk::common::internal_log::LogLevel::None: + break; + case opentelemetry::sdk::common::internal_log::LogLevel::Error: + fprintf(stdout, "[ERROR] %s\n", msg); + break; + case opentelemetry::sdk::common::internal_log::LogLevel::Warning: + fprintf(stdout, "[WARNING] %s\n", msg); + break; + case opentelemetry::sdk::common::internal_log::LogLevel::Info: + fprintf(stdout, "[INFO] %s\n", msg); + break; + case opentelemetry::sdk::common::internal_log::LogLevel::Debug: + fprintf(stdout, "[DEBUG] %s\n", msg); + break; + } + } +}; + +void SetLoggerForTesting() +{ + if (opt_test) + { + opentelemetry::nostd::shared_ptr + checker_log_handler(new CheckerLogHandler()); + + opentelemetry::sdk::common::internal_log::GlobalLogHandler::SetLogHandler(checker_log_handler); + } +} + +void PrintModelParsedForTesting(bool pass) +{ + if (opt_test) + { + if (pass) + { + fprintf(stdout, "MODEL PARSED\n"); + } + else + { + fprintf(stdout, "FAILED TO PARSE MODEL\n"); + exit(1); + } + } +} + +void PrintSdkCreatedForTesting(bool pass) +{ + if (opt_test) + { + if (pass) + { + fprintf(stdout, "SDK CREATED\n"); + } + else + { + fprintf(stdout, "FAILED TO CREATE SDK\n"); + exit(2); + } + } +} + +void SetSilentLoggerForTesting() +{ + if (opt_test) + { + // Do not record noise during payload, + // so it does not go into the shelltest output. + auto level = opentelemetry::sdk::common::internal_log::LogLevel::None; + opentelemetry::sdk::common::internal_log::GlobalLogHandler::SetLogLevel(level); + } +} + +void InitOtel(const std::string &config_file) +{ + auto level = opentelemetry::sdk::common::internal_log::LogLevel::Info; + + if (opt_debug) + { + level = opentelemetry::sdk::common::internal_log::LogLevel::Debug; + } + + opentelemetry::sdk::common::internal_log::GlobalLogHandler::SetLogLevel(level); + + /* 1 - Create a registry */ + + std::shared_ptr registry( + new opentelemetry::sdk::configuration::Registry); + + /* 2 - Populate the registry with the core components supported */ + + /* + * Note: + * + * In a typical application, decide which component are allowed, and just + * Register them, without compile time (#ifdef OTEL_HAVE_OTLP_HTTP) + * or runtime (opt_no_registry) logic. + * + * Because this example is used in CI with various build configurations, + * we add compile time checks to have a working build in all cases. + * Do not use ifdef, just pick the components the application uses. + * + * Also, because this example is used in CI to run functional tests, + * we add a runtime check to execute stress tests for coverage. + * Do not blindly copy and paste if(!opt_no_registry), it is test code. + */ + + if (!opt_no_registry) + { + opentelemetry::exporter::trace::ConsoleSpanBuilder::Register(registry.get()); + opentelemetry::exporter::metrics::ConsolePushMetricBuilder::Register(registry.get()); + opentelemetry::exporter::logs::ConsoleLogRecordBuilder::Register(registry.get()); + +#ifdef OTEL_HAVE_OTLP_HTTP + opentelemetry::exporter::otlp::OtlpHttpSpanBuilder::Register(registry.get()); + opentelemetry::exporter::otlp::OtlpHttpPushMetricBuilder::Register(registry.get()); + opentelemetry::exporter::otlp::OtlpHttpLogRecordBuilder::Register(registry.get()); +#endif + +#ifdef OTEL_HAVE_OTLP_GRPC + opentelemetry::exporter::otlp::OtlpGrpcSpanBuilder::Register(registry.get()); + opentelemetry::exporter::otlp::OtlpGrpcPushMetricBuilder::Register(registry.get()); + opentelemetry::exporter::otlp::OtlpGrpcLogRecordBuilder::Register(registry.get()); +#endif + +#ifdef OTEL_HAVE_OTLP_FILE + opentelemetry::exporter::otlp::OtlpFileSpanBuilder::Register(registry.get()); + opentelemetry::exporter::otlp::OtlpFilePushMetricBuilder::Register(registry.get()); + opentelemetry::exporter::otlp::OtlpFileLogRecordBuilder::Register(registry.get()); +#endif + +#ifdef OTEL_HAVE_ZIPKIN + opentelemetry::exporter::zipkin::ZipkinBuilder::Register(registry.get()); +#endif + +#ifdef OTEL_HAVE_PROMETHEUS + opentelemetry::exporter::metrics::PrometheusPullBuilder::Register(registry.get()); +#endif + } + + /* 3 - Populate the registry with external extensions plugins */ + + CustomSamplerBuilder::Register(registry.get()); + CustomSpanExporterBuilder::Register(registry.get()); + CustomSpanProcessorBuilder::Register(registry.get()); + CustomPushMetricExporterBuilder::Register(registry.get()); + CustomPullMetricExporterBuilder::Register(registry.get()); + CustomLogRecordExporterBuilder::Register(registry.get()); + CustomLogRecordProcessorBuilder::Register(registry.get()); + + /* 4 - Parse a config.yaml */ + + // See + // https://github.com/open-telemetry/opentelemetry-configuration/blob/main/examples/kitchen-sink.yaml + auto model = opentelemetry::sdk::configuration::YamlConfigurationParser::ParseFile(config_file); + + // Functional test helpers, ignore. + PrintModelParsedForTesting(model != nullptr); + + /* 5 - Build the SDK from the parsed config.yaml */ + + sdk = opentelemetry::sdk::configuration::ConfiguredSdk::Create(registry, model); + + // Functional test helpers, ignore. + PrintSdkCreatedForTesting(sdk != nullptr); + + /* 6 - Deploy the SDK */ + + if (sdk != nullptr) + { + sdk->Install(); + } +} + +void CleanupOtel() +{ + if (sdk != nullptr) + { + sdk->UnInstall(); + } + sdk.reset(nullptr); +} +} // namespace + +static void usage(FILE *out) +{ + static const char *msg = + "Usage: example_yaml [options]\n" + "Valid options are:\n" + " --help\n" + " Print this help\n" + " --yaml \n" + " Path to a yaml configuration file\n" + " --debug\n" + " Set logger to debug\n" + "\n" + "The configuration file used will be:\n" + " 1) the file provided in the command line\n" + " 2) the file provided in environment variable ${OTEL_EXPERIMENTAL_CONFIG_FILE}\n" + " 3) file config.yaml\n" + "\n" + "This utility is also used for functional tests.\n" + "\n" + "Valid test options are:\n" + " --test\n" + " Run in test mode\n" + " --no-registry\n" + " Run with an empty registry\n"; + + fprintf(out, "%s", msg); +} + +static int parse_args(int argc, char *argv[]) +{ + int remaining_argc = argc; + char **remaining_argv = argv; + + while (remaining_argc > 0) + { + if (strcmp(*remaining_argv, "--help") == 0) + { + opt_help = true; + return 0; + } + + if (remaining_argc >= 2) + { + if (strcmp(*remaining_argv, "--yaml") == 0) + { + remaining_argc--; + remaining_argv++; + yaml_file_path = *remaining_argv; + remaining_argc--; + remaining_argv++; + continue; + } + } + + if (strcmp(*remaining_argv, "--debug") == 0) + { + remaining_argc--; + remaining_argv++; + opt_debug = true; + continue; + } + + if (strcmp(*remaining_argv, "--test") == 0) + { + remaining_argc--; + remaining_argv++; + opt_test = true; + continue; + } + + if (strcmp(*remaining_argv, "--no-registry") == 0) + { + remaining_argc--; + remaining_argv++; + opt_no_registry = true; + continue; + } + + if (remaining_argc) + { + // Unknown option + return 1; + } + } + + return 0; +} + +int main(int argc, char *argv[]) +{ + // Program name + argc--; + argv++; + + int rc = parse_args(argc, argv); + + if (rc != 0) + { + usage(stderr); + return 1; + } + + if (opt_help) + { + usage(stdout); + return 0; + } + + // Functional test helpers, ignore. + SetLoggerForTesting(); + + InitOtel(yaml_file_path); + + // Functional test helpers, ignore. + SetSilentLoggerForTesting(); + + foo_library(); + foo_library::counter_example("yaml"); + foo_library::observable_counter_example("yaml"); + foo_library::histogram_example("yaml"); + + CleanupOtel(); + return 0; +}