[CONFIGURATION] File configuration - resource detectors

sdk/include/opentelemetry/sdk/configuration/configuration_parser.h

@@ -81,6 +81,8 @@
 #include "opentelemetry/sdk/configuration/pull_metric_reader_configuration.h"
 #include "opentelemetry/sdk/configuration/push_metric_exporter_configuration.h"
 #include "opentelemetry/sdk/configuration/resource_configuration.h"
+#include "opentelemetry/sdk/configuration/resource_detection_configuration.h"
+#include "opentelemetry/sdk/configuration/resource_detector_configuration.h"
 #include "opentelemetry/sdk/configuration/sampler_configuration.h"
 #include "opentelemetry/sdk/configuration/severity_number.h"
 #include "opentelemetry/sdk/configuration/simple_log_record_processor_configuration.h"
@@ -438,6 +440,12 @@ class ConfigurationParser
   std::unique_ptr<ResourceConfiguration> ParseResourceConfiguration(
       const std::unique_ptr<DocumentNode> &node) const;
 
+  std::unique_ptr<ResourceDetectionConfiguration> ParseResourceDetectionConfiguration(
+      const std::unique_ptr<DocumentNode> &node) const;
+
+  std::unique_ptr<ResourceDetectorConfiguration> ParseResourceDetectorConfiguration(
+      const std::unique_ptr<DocumentNode> &node) const;
+
   std::unique_ptr<DistributionConfiguration> ParseDistributionConfiguration(
       const std::unique_ptr<DocumentNode> &node) const;
 

sdk/include/opentelemetry/sdk/configuration/container_resource_detector_configuration.h

@@ -0,0 +1,29 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/sdk/configuration/resource_detector_configuration.h"
+#include "opentelemetry/sdk/configuration/resource_detector_configuration_visitor.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+// YAML-SCHEMA: schema/resource.yaml
+// YAML-NODE: ExperimentalContainerResourceDetector
+class ContainerResourceDetectorConfiguration : public ResourceDetectorConfiguration
+{
+public:
+  void Accept(ResourceDetectorConfigurationVisitor *visitor) const override
+  {
+    visitor->VisitContainer(this);
+  }
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/extension_resource_detector_builder.h

@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/extension_resource_detector_configuration.h"
+#include "opentelemetry/sdk/resource/resource_detector.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ExtensionResourceDetectorBuilder
+{
+public:
+  ExtensionResourceDetectorBuilder()                                            = default;
+  ExtensionResourceDetectorBuilder(ExtensionResourceDetectorBuilder &&)         = default;
+  ExtensionResourceDetectorBuilder(const ExtensionResourceDetectorBuilder &)    = default;
+  ExtensionResourceDetectorBuilder &operator=(ExtensionResourceDetectorBuilder &&) = default;
+  ExtensionResourceDetectorBuilder &operator=(const ExtensionResourceDetectorBuilder &other) =
+      default;
+  virtual ~ExtensionResourceDetectorBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::resource::ResourceDetector> Build(
+      const opentelemetry::sdk::configuration::ExtensionResourceDetectorConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/extension_resource_detector_configuration.h

@@ -0,0 +1,34 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "opentelemetry/sdk/configuration/document_node.h"
+#include "opentelemetry/sdk/configuration/resource_detector_configuration.h"
+#include "opentelemetry/sdk/configuration/resource_detector_configuration_visitor.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ExtensionResourceDetectorConfiguration : public ResourceDetectorConfiguration
+{
+public:
+  void Accept(ResourceDetectorConfigurationVisitor *visitor) const override
+  {
+    visitor->VisitExtension(this);
+  }
+
+  std::string name;
+  std::unique_ptr<DocumentNode> node;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/registry.h

@@ -11,6 +11,7 @@
 #include "opentelemetry/sdk/configuration/console_span_exporter_builder.h"
 #include "opentelemetry/sdk/configuration/extension_log_record_exporter_builder.h"
 #include "opentelemetry/sdk/configuration/extension_log_record_processor_builder.h"
+#include "opentelemetry/sdk/configuration/extension_resource_detector_builder.h"
 #include "opentelemetry/sdk/configuration/extension_pull_metric_exporter_builder.h"
 #include "opentelemetry/sdk/configuration/extension_push_metric_exporter_builder.h"
 #include "opentelemetry/sdk/configuration/extension_sampler_builder.h"
@@ -235,6 +236,13 @@ class Registry
       const std::string &name,
       std::unique_ptr<ExtensionLogRecordProcessorBuilder> &&builder);
 
+  const ExtensionResourceDetectorBuilder *GetExtensionResourceDetectorBuilder(
+      const std::string &name) const;
+
+  void SetExtensionResourceDetectorBuilder(
+      const std::string &name,
+      std::unique_ptr<ExtensionResourceDetectorBuilder> &&builder);
+
 private:
   std::unique_ptr<OtlpHttpSpanExporterBuilder> otlp_http_span_builder_;
   std::unique_ptr<OtlpGrpcSpanExporterBuilder> otlp_grpc_span_builder_;
@@ -264,6 +272,8 @@ class Registry
       log_record_exporter_builders_;
   std::map<std::string, std::unique_ptr<ExtensionLogRecordProcessorBuilder>>
       log_record_processor_builders_;
+  std::map<std::string, std::unique_ptr<ExtensionResourceDetectorBuilder>>
+      resource_detector_builders_;
 };
 
 }  // namespace configuration

sdk/include/opentelemetry/sdk/configuration/resource_configuration.h

@@ -8,6 +8,7 @@
 
 #include "opentelemetry/sdk/configuration/attributes_configuration.h"
 #include "opentelemetry/sdk/configuration/include_exclude_configuration.h"
+#include "opentelemetry/sdk/configuration/resource_detection_configuration.h"
 #include "opentelemetry/version.h"
 
 OPENTELEMETRY_BEGIN_NAMESPACE
@@ -16,13 +17,14 @@ namespace sdk
 namespace configuration
 {
 
-// YAML-SCHEMA: schema/resource.json
+// YAML-SCHEMA: schema/resource.yaml
 // YAML-NODE: Resource
 class ResourceConfiguration
 {
 public:
   std::unique_ptr<AttributesConfiguration> attributes;
   std::unique_ptr<IncludeExcludeConfiguration> detectors;
+  std::unique_ptr<ResourceDetectionConfiguration> detection;
   std::string schema_url;
   std::string attributes_list;
 };

sdk/include/opentelemetry/sdk/configuration/resource_detection_configuration.h

@@ -0,0 +1,30 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "opentelemetry/sdk/configuration/include_exclude_configuration.h"
+#include "opentelemetry/sdk/configuration/resource_detector_configuration.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+// YAML-SCHEMA: schema/resource.yaml
+// YAML-NODE: ExperimentalResourceDetection
+class ResourceDetectionConfiguration
+{
+public:
+  std::unique_ptr<IncludeExcludeConfiguration> attributes;
+  std::vector<std::unique_ptr<ResourceDetectorConfiguration>> detectors;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/resource_detector_configuration.h

@@ -0,0 +1,33 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ResourceDetectorConfigurationVisitor;
+
+// YAML-SCHEMA: schema/resource.yaml
+// YAML-NODE: ExperimentalResourceDetector
+class ResourceDetectorConfiguration
+{
+public:
+  ResourceDetectorConfiguration()                                                     = default;
+  ResourceDetectorConfiguration(ResourceDetectorConfiguration &&)                     = default;
+  ResourceDetectorConfiguration(const ResourceDetectorConfiguration &)                = default;
+  ResourceDetectorConfiguration &operator=(ResourceDetectorConfiguration &&)           = default;
+  ResourceDetectorConfiguration &operator=(const ResourceDetectorConfiguration &other) = default;
+  virtual ~ResourceDetectorConfiguration()                                            = default;
+
+  virtual void Accept(ResourceDetectorConfigurationVisitor *visitor) const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/resource_detector_configuration_visitor.h

@@ -0,0 +1,29 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ContainerResourceDetectorConfiguration;
+class ExtensionResourceDetectorConfiguration;
+
+class ResourceDetectorConfigurationVisitor
+{
+public:
+  ResourceDetectorConfigurationVisitor()          = default;
+  virtual ~ResourceDetectorConfigurationVisitor() = default;
+
+  virtual void VisitContainer(const ContainerResourceDetectorConfiguration *model) = 0;
+  virtual void VisitExtension(const ExtensionResourceDetectorConfiguration *model) = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/configuration/sdk_builder.h

@@ -22,6 +22,7 @@
 #include "opentelemetry/sdk/configuration/extension_push_metric_exporter_configuration.h"
 #include "opentelemetry/sdk/configuration/extension_span_exporter_configuration.h"
 #include "opentelemetry/sdk/configuration/extension_span_processor_configuration.h"
+#include "opentelemetry/sdk/configuration/resource_detection_configuration.h"
 #include "opentelemetry/sdk/configuration/integer_array_attribute_value_configuration.h"
 #include "opentelemetry/sdk/configuration/integer_attribute_value_configuration.h"
 #include "opentelemetry/sdk/configuration/logger_configurator_configuration.h"
@@ -274,6 +275,11 @@ class SdkBuilder
                    const std::unique_ptr<opentelemetry::sdk::configuration::ResourceConfiguration>
                        &opt_model) const;
 
+  void ApplyResourceDetection(
+      opentelemetry::sdk::resource::Resource &resource,
+      const std::unique_ptr<opentelemetry::sdk::configuration::ResourceDetectionConfiguration>
+          &detection) const;
+
   void SetLogLevel(opentelemetry::sdk::common::internal_log::LogLevel &sdk_log_level,
                    opentelemetry::sdk::configuration::SeverityNumber model_log_level) const;
 

sdk/src/configuration/configuration_parser.cc

@@ -100,6 +100,10 @@
 #include "opentelemetry/sdk/configuration/pull_metric_reader_configuration.h"
 #include "opentelemetry/sdk/configuration/push_metric_exporter_configuration.h"
 #include "opentelemetry/sdk/configuration/resource_configuration.h"
+#include "opentelemetry/sdk/configuration/resource_detection_configuration.h"
+#include "opentelemetry/sdk/configuration/resource_detector_configuration.h"
+#include "opentelemetry/sdk/configuration/container_resource_detector_configuration.h"
+#include "opentelemetry/sdk/configuration/extension_resource_detector_configuration.h"
 #include "opentelemetry/sdk/configuration/sampler_configuration.h"
 #include "opentelemetry/sdk/configuration/severity_number.h"
 #include "opentelemetry/sdk/configuration/simple_log_record_processor_configuration.h"
@@ -2519,9 +2523,67 @@ std::unique_ptr<ResourceConfiguration> ConfigurationParser::ParseResourceConfigu
     model->detectors = ParseIncludeExcludeConfiguration(child);
   }
 
+  child = node->GetChildNode("detection/development");
+  if (child)
+  {
+    model->detection = ParseResourceDetectionConfiguration(child);
+  }
+
   return model;
 }
 
+std::unique_ptr<ResourceDetectionConfiguration>
+ConfigurationParser::ParseResourceDetectionConfiguration(
+    const std::unique_ptr<DocumentNode> &node) const
+{
+  auto model = std::make_unique<ResourceDetectionConfiguration>();
+  std::unique_ptr<DocumentNode> child;
+
+  child = node->GetChildNode("attributes");
+  if (child)
+  {
+    model->attributes = ParseIncludeExcludeConfiguration(child);
+  }
+
+  child = node->GetChildNode("detectors");
+  if (child)
+  {
+    for (auto it = child->begin(); it != child->end(); ++it)
+    {
+      std::unique_ptr<DocumentNode> detector_node(*it);
+      auto detector = ParseResourceDetectorConfiguration(detector_node);
+      model->detectors.push_back(std::move(detector));
+    }
+  }
+
+  return model;
+}
+
+std::unique_ptr<ResourceDetectorConfiguration>
+ConfigurationParser::ParseResourceDetectorConfiguration(
+    const std::unique_ptr<DocumentNode> &node) const
+{
+  for (auto it = node->begin_properties(); it != node->end_properties(); ++it)
+  {
+    std::string name = it.Name();
+
+    if (name == "container")
+    {
+      return std::make_unique<ContainerResourceDetectorConfiguration>();
+    }
+    else
+    {
+      auto extension  = std::make_unique<ExtensionResourceDetectorConfiguration>();
+      extension->name = name;
+      extension->node = it.Value();
+      return extension;
+    }
+  }
+
+  std::string message("Illegal resource detector, 0 entries");
+  throw InvalidSchemaException(node->Location(), message);
+}
+
 std::unique_ptr<DistributionConfiguration> ConfigurationParser::ParseDistributionConfiguration(
     const std::unique_ptr<DocumentNode> &node) const
 {