[SDK] Implementation of container resource as per semconv

CMakeLists.txt

@@ -634,6 +634,7 @@ if(DEFINED OPENTELEMETRY_BUILD_DLL)
 endif()
 
 add_subdirectory(api)
+add_subdirectory(resource_detectors)
 
 if(WITH_OPENTRACING)
   add_subdirectory(opentracing-shim)

resource_detectors/BUILD

@@ -0,0 +1,24 @@
+# Copyright The OpenTelemetry Authors
+# SPDX-License-Identifier: Apache-2.0
+
+package(default_visibility = ["//visibility:public"])
+
+cc_library(
+    name = "headers",
+    hdrs = glob(["include/**/*.h"]),
+    strip_include_prefix = "include",
+)
+
+cc_library(
+    name = "resource_detectors",
+    srcs = [
+        "container.cc",
+        "container_detector.cc",
+    ],
+    deps = [
+        "//api",
+        "//resource_detectors:headers",
+        "//sdk:headers",
+        "//sdk/src/resource",
+    ],
+)

resource_detectors/CMakeLists.txt

@@ -0,0 +1,23 @@
+# Copyright The OpenTelemetry Authors
+# SPDX-License-Identifier: Apache-2.0
+
+add_library(opentelemetry_resource_detectors container.cc container_detector.cc)
+
+set_target_properties(opentelemetry_resource_detectors
+                      PROPERTIES EXPORT_NAME resource_detectors)
+set_target_version(opentelemetry_resource_detectors)
+
+target_link_libraries(opentelemetry_resource_detectors
+                      PUBLIC opentelemetry_common)
+
+target_include_directories(
+  opentelemetry_resource_detectors
+  PUBLIC "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/resource_detectors/include>"
+  PUBLIC "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/sdk/include>")
+
+if(OPENTELEMETRY_INSTALL)
+  opentelemetry_add_pkgconfig(
+    resource_detectors "OpenTelemetry - Resource detectors"
+    "Components for resource detection in the OpenTelemetry resource detectors."
+  )
+endif()

resource_detectors/container.cc

@@ -0,0 +1,47 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/resource_detectors/container_resource_detector.h"
+
+#include <fstream>
+#include <regex>
+#include <string>
+
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace resource
+{
+std::string GetContainerIDFromCgroup(const char *file_path)
+{
+  std::ifstream cgroup_file(file_path);
+  std::string line;
+
+  while (std::getline(cgroup_file, line))
+  {
+    std::string container_id = ExtractContainerIDFromLine(line);
+    if (!container_id.empty())
+    {
+      return container_id;
+    }
+  }
+  return "";
+}
+
+std::string ExtractContainerIDFromLine(const std::string &line)
+{
+  static const std::regex container_id_regex(R"(^.*/(?:.*[-:])?([0-9a-f]+)(?:\.|\s*$))");
+  std::smatch match;
+
+  if (std::regex_search(line, match, container_id_regex))
+  {
+    return match.str(1);
+  }
+
+  return "";
+}
+}  // namespace resource
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

resource_detectors/container_detector.cc

@@ -0,0 +1,41 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/nostd/variant.h"
+#include "opentelemetry/resource_detectors/container_resource_detector.h"
+#include "opentelemetry/sdk/resource/resource.h"
+#include "opentelemetry/sdk/resource/resource_detector.h"
+#include "opentelemetry/semconv/incubating/container_attributes.h"
+#include "opentelemetry/version.h"
+
+#include <string>
+#include <unordered_map>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace resource
+{
+
+/**
+ * This is the file path from where we can get container.id
+ */
+const char *KCGroupPath = "/proc/self/cgroup";
+
+Resource ContainerResourceDetector::Detect() noexcept
+{
+  std::string container_id = opentelemetry::sdk::resource::GetContainerIDFromCgroup(KCGroupPath);
+  if (container_id.empty())
+  {
+    return ResourceDetector::Create({});
+  }
+
+  ResourceAttributes attributes;
+
+  attributes[semconv::container::kContainerId] = container_id;
+  return ResourceDetector::Create(attributes);
+}
+
+}  // namespace resource
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

resource_detectors/include/opentelemetry/resource_detectors/container_resource_detector.h

@@ -0,0 +1,43 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/sdk/resource/resource.h"
+#include "opentelemetry/sdk/resource/resource_detector.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace resource
+{
+
+/**
+ * ContainerResourceDetector to detect resource attributes when running inside a containerized
+ * environment. This detector extracts metadata such as container ID from cgroup information and
+ * sets attributes like container.id following the OpenTelemetry semantic conventions.
+ */
+class ContainerResourceDetector : public ResourceDetector
+{
+public:
+  Resource Detect() noexcept override;
+};
+
+/**
+ * Reads the container.id from /proc/self/cgroup file.
+ * @param file_path file path of cgroup
+ * @return container.id as string or empty string
+ */
+std::string GetContainerIDFromCgroup(const char *file_path);
+
+/**
+ * Matches the line with the regex to find container.id
+ * @param line a single line of text, typically from the /proc/self/cgroup file
+ * @return matched id or empty string
+ */
+std::string ExtractContainerIDFromLine(const std::string &line);
+
+}  // namespace resource
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/src/resource/resource_detector.cc

@@ -19,8 +19,8 @@ namespace sdk
 namespace resource
 {
 
-const char *OTEL_RESOURCE_ATTRIBUTES = "OTEL_RESOURCE_ATTRIBUTES";
-const char *OTEL_SERVICE_NAME        = "OTEL_SERVICE_NAME";
+const char *KOtelResourceAttributes = "OTEL_RESOURCE_ATTRIBUTES";
+const char *KOtelServiceName        = "OTEL_SERVICE_NAME";
 
 Resource ResourceDetector::Create(const ResourceAttributes &attributes,
                                   const std::string &schema_url)
@@ -33,9 +33,9 @@ Resource OTELResourceDetector::Detect() noexcept
   std::string attributes_str, service_name;
 
   bool attributes_exists = opentelemetry::sdk::common::GetStringEnvironmentVariable(
-      OTEL_RESOURCE_ATTRIBUTES, attributes_str);
+      KOtelResourceAttributes, attributes_str);
   bool service_name_exists =
-      opentelemetry::sdk::common::GetStringEnvironmentVariable(OTEL_SERVICE_NAME, service_name);
+      opentelemetry::sdk::common::GetStringEnvironmentVariable(KOtelServiceName, service_name);
 
   if (!attributes_exists && !service_name_exists)
   {

sdk/test/resource/BUILD

@@ -9,6 +9,7 @@ cc_test(
     tags = ["test"],
     deps = [
         "//api",
+        "//resource_detectors",
         "//sdk/src/resource",
         "@com_google_googletest//:gtest_main",
     ],

sdk/test/resource/CMakeLists.txt

@@ -3,8 +3,9 @@
 
 foreach(testname resource_test)
   add_executable(${testname} "${testname}.cc")
-  target_link_libraries(${testname} ${GTEST_BOTH_LIBRARIES}
-                        ${CMAKE_THREAD_LIBS_INIT} opentelemetry_resources)
+  target_link_libraries(
+    ${testname} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
+    opentelemetry_resources opentelemetry_resource_detectors)
   gtest_add_tests(
     TARGET ${testname}
     TEST_PREFIX resources.

sdk/test/resource/resource_test.cc

@@ -3,13 +3,16 @@
 
 #include <gtest/gtest.h>
 #include <stdint.h>
+#include <cstdio>
 #include <cstdlib>
+#include <fstream>
 #include <map>
 #include <string>
 #include <unordered_map>
 #include <utility>
 
 #include "opentelemetry/nostd/variant.h"
+#include "opentelemetry/resource_detectors/container_resource_detector.h"
 #include "opentelemetry/sdk/common/attribute_utils.h"
 #include "opentelemetry/sdk/resource/resource.h"
 #include "opentelemetry/sdk/resource/resource_detector.h"
@@ -292,3 +295,52 @@ TEST(ResourceTest, DerivedResourceDetector)
   EXPECT_EQ(resource.GetSchemaURL(), detector.schema_url);
   EXPECT_TRUE(received_attributes.find("key") != received_attributes.end());
 }
+
+TEST(ResourceTest, ExtractValidContainerId)
+{
+  std::string line =
+      "13:name=systemd:/podruntime/docker/kubepods/ac679f8a8319c8cf7d38e1adf263bc08d23.aaaa";
+  std::string extracted_id = opentelemetry::sdk::resource::ExtractContainerIDFromLine(line);
+  EXPECT_EQ(std::string{"ac679f8a8319c8cf7d38e1adf263bc08d23"}, extracted_id);
+}
+
+TEST(ResourceTest, ExtractIdFromMockUpCGroupFile)
+{
+  const char *filename = "test_cgroup.txt";
+
+  {
+    std::ofstream outfile(filename);
+    outfile << "13:name=systemd:/kuberuntime/containerd"
+               "/kubepods-pod872d2066_00ef_48ea_a7d8_51b18b72d739:cri-containerd:"
+               "e857a4bf05a69080a759574949d7a0e69572e27647800fa7faff6a05a8332aa1\n";
+    outfile << "9:cpu:/not-a-container\n";
+  }
+
+  std::string container_id = opentelemetry::sdk::resource::GetContainerIDFromCgroup(filename);
+  EXPECT_EQ(container_id,
+            std::string{"e857a4bf05a69080a759574949d7a0e69572e27647800fa7faff6a05a8332aa1"});
+
+  std::remove(filename);
+}
+
+TEST(ResourceTest, DoesNotExtractInvalidLine)
+{
+  std::string line = "this line does not contain a container id";
+  std::string id   = opentelemetry::sdk::resource::ExtractContainerIDFromLine(line);
+  EXPECT_EQ(id, std::string{""});
+}
+
+TEST(ContainerIdDetectorTest, ReturnsEmptyOnNoMatch)
+{
+  const char *filename = "test_empty_cgroup.txt";
+
+  {
+    std::ofstream outfile(filename);
+    outfile << "no container id here\n";
+  }
+
+  std::string id = opentelemetry::sdk::resource::GetContainerIDFromCgroup(filename);
+  EXPECT_EQ(id, std::string{""});
+
+  std::remove(filename);  // cleanup
+}