[CONFIGURATION] File configuration - configuration example

Author: marcalff

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<opentelemetry::sdk::logs::Recordable>
+CustomLogRecordExporter::MakeRecordable() noexcept
+{
+  auto recordable = std::make_unique<opentelemetry::sdk::logs::ReadWriteLogRecord>();
+  return recordable;
+}
+
+opentelemetry::sdk::common::ExportResult CustomLogRecordExporter::Export(
+    const opentelemetry::nostd::span<std::unique_ptr<opentelemetry::sdk::logs::Recordable>>
+        & /* 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;
+}

examples/configuration/custom_log_record_exporter.h

@@ -0,0 +1,34 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <chrono>
+#include <memory>
+#include <string>
+
+#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 */) {}
+  CustomLogRecordExporter(CustomLogRecordExporter &&)                      = delete;
+  CustomLogRecordExporter(const CustomLogRecordExporter &)                 = delete;
+  CustomLogRecordExporter &operator=(CustomLogRecordExporter &&)           = delete;
+  CustomLogRecordExporter &operator=(const CustomLogRecordExporter &other) = delete;
+  ~CustomLogRecordExporter() override                                      = default;
+
+  std::unique_ptr<opentelemetry::sdk::logs::Recordable> MakeRecordable() noexcept override;
+
+  opentelemetry::sdk::common::ExportResult Export(
+      const opentelemetry::nostd::span<std::unique_ptr<opentelemetry::sdk::logs::Recordable>>
+          &records) noexcept override;
+
+  bool ForceFlush(std::chrono::microseconds timeout) noexcept override;
+
+  bool Shutdown(std::chrono::microseconds timeout) noexcept override;
+};

examples/configuration/custom_log_record_exporter_builder.cc

@@ -0,0 +1,31 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <string>
+#include <utility>
+
+#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<opentelemetry::sdk::logs::LogRecordExporter> CustomLogRecordExporterBuilder::Build(
+    const opentelemetry::sdk::configuration::ExtensionLogRecordExporterConfiguration *model) const
+{
+  // Read yaml attributes
+  std::string comment = model->node->GetRequiredString("comment");
+
+  auto sdk = std::make_unique<CustomLogRecordExporter>(comment);
+
+  return sdk;
+}
+
+void CustomLogRecordExporterBuilder::Register(opentelemetry::sdk::configuration::Registry *registry)
+{
+  auto builder = std::make_unique<CustomLogRecordExporterBuilder>();
+  registry->SetExtensionLogRecordExporterBuilder("my_custom_log_record_exporter",
+                                                 std::move(builder));
+}

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 <memory>
+
+#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<opentelemetry::sdk::logs::LogRecordExporter> Build(
+      const opentelemetry::sdk::configuration::ExtensionLogRecordExporterConfiguration *model)
+      const override;
+};

examples/configuration/custom_log_record_processor.cc

@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <utility>
+
+#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<opentelemetry::sdk::logs::Recordable>
+CustomLogRecordProcessor::MakeRecordable() noexcept
+{
+  auto recordable = std::make_unique<opentelemetry::sdk::logs::ReadWriteLogRecord>();
+  return recordable;
+}
+
+void CustomLogRecordProcessor::OnEmit(
+    std::unique_ptr<opentelemetry::sdk::logs::Recordable> &&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;
+}

examples/configuration/custom_log_record_processor.h

@@ -0,0 +1,33 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <chrono>
+#include <memory>
+#include <string>
+
+#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) : m_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<opentelemetry::sdk::logs::Recordable> MakeRecordable() noexcept override;
+
+  void OnEmit(std::unique_ptr<opentelemetry::sdk::logs::Recordable> &&record) noexcept override;
+
+  bool ForceFlush(std::chrono::microseconds timeout) noexcept override;
+
+  bool Shutdown(std::chrono::microseconds timeout) noexcept override;
+
+private:
+  std::string m_comment;
+};

examples/configuration/custom_log_record_processor_builder.cc

@@ -0,0 +1,33 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <string>
+#include <utility>
+
+#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<opentelemetry::sdk::logs::LogRecordProcessor>
+CustomLogRecordProcessorBuilder::Build(
+    const opentelemetry::sdk::configuration::ExtensionLogRecordProcessorConfiguration *model) const
+{
+  // Read yaml attributes
+  std::string comment = model->node->GetRequiredString("comment");
+
+  auto sdk = std::make_unique<CustomLogRecordProcessor>(comment);
+
+  return sdk;
+}
+
+void CustomLogRecordProcessorBuilder::Register(
+    opentelemetry::sdk::configuration::Registry *registry)
+{
+  auto builder = std::make_unique<CustomLogRecordProcessorBuilder>();
+  registry->SetExtensionLogRecordProcessorBuilder("my_custom_log_record_processor",
+                                                  std::move(builder));
+}

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 <memory>
+
+#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<opentelemetry::sdk::logs::LogRecordProcessor> Build(
+      const opentelemetry::sdk::configuration::ExtensionLogRecordProcessorConfiguration *model)
+      const override;
+};

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");
+}

examples/configuration/custom_pull_metric_exporter.h

@@ -0,0 +1,30 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <chrono>
+#include <string>
+
+#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 */) {}
+  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;
+};