[extension/cgroupruntime] Be aware of ECS task and CPU limits

.chloggen/check-ecs-metadata-cgroupruntimeextension.yaml

@@ -0,0 +1,27 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: cgroupruntimeextension
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Implement ECS metadata retrieval for cgroupruntime extension.
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [36814]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
+
+# If your change doesn't affect end users or the exported elements of any package,
+# you should instead start your pull request title with [chore] or use the "Skip Changelog" label.
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: []

extension/cgroupruntimeextension/CONTRIBUTING.md

@@ -0,0 +1,26 @@
+# Contributing to the Cgroup Go runtime extension
+
+In order to contribute to this extension, it might be useful to have a working local setup.
+
+## Testing
+
+To run the integration tests locally for this extension, you can follow theses steps in a Linux environment.
+
+Inside the extension folder, start a privileged docker container and share the code with the container
+
+```bash
+cd extension/cgroupruntimeextension
+docker run -ti --privileged --cgroupns=host -v $(pwd):/workspace -w /workspace debian:bookworm-slim
+```
+
+Install Go and gcc to run the integration test
+
+```bash
+apt update && apt install -y wget sudo gcc && wget https://go.dev/dl/go1.23.4.linux-amd64.tar.gz && tar -C /usr/local -xzf go1.23.4.linux-amd64.tar.gz && export PATH=$PATH:/usr/local/go/bin && go version && rm go1.23.4.linux-amd64.tar.gz
+```
+
+Run the integration test
+
+```bash
+CGO_ENABLED=1 go test -v -exec sudo -race -timeout 360s -parallel 4 -tags=integration,""
+```

extension/cgroupruntimeextension/README.md

@@ -15,7 +15,7 @@
 
 ## Overview
 
-The OpenTelemetry Cgroup Auto-Config Extension is designed to optimize Go runtime performance in containerized environments by automatically configuring GOMAXPROCS and GOMEMLIMIT based on the Linux cgroup filesystem. This extension leverages [automaxprocs](https://github.com/uber-go/automaxprocs) and [automemlimit](https://github.com/KimMachineGun/automemlimit) packages to dynamically adjust Go runtime variables, ensuring efficient resource usage aligned with container limits.
+The OpenTelemetry Cgroup Auto-Config Extension is designed to optimize Go runtime performance in containerized environments by automatically configuring GOMAXPROCS and GOMEMLIMIT based on the Linux cgroup filesystem. This extension leverages [automaxprocs](https://github.com/uber-go/automaxprocs) or [gomaxecs](https://github.com/rdforte/gomaxecs) for AWS ECS Tasks and [automemlimit](https://github.com/KimMachineGun/automemlimit) packages to dynamically adjust Go runtime variables, ensuring efficient resource usage aligned with container limits.
 
 ## Configuration
 
@@ -40,3 +40,7 @@ extension:
         enabled: true
         ratio: 0.8
 ```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for information on how to contribute to this extension.

extension/cgroupruntimeextension/factory.go

@@ -9,6 +9,7 @@ import (
 	"runtime/debug"
 
 	"github.com/KimMachineGun/automemlimit/memlimit"
+	gomaxecs "github.com/rdforte/gomaxecs/maxprocs"
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/extension"
 	"go.uber.org/automaxprocs/maxprocs"
@@ -42,10 +43,14 @@ func createExtension(_ context.Context, set extension.Settings, cfg component.Co
 	cgroupConfig := cfg.(*Config)
 	return newCgroupRuntime(cgroupConfig, set.Logger,
 		func() (undoFunc, error) {
-			undo, err := maxprocs.Set(maxprocs.Logger(func(str string, params ...any) {
+			if gomaxecs.IsECS() {
+				return gomaxecs.Set(gomaxecs.WithLogger(func(str string, params ...any) {
+					set.Logger.Debug(fmt.Sprintf(str, params))
+				}))
+			}
+			return maxprocs.Set(maxprocs.Logger(func(str string, params ...any) {
 				set.Logger.Debug(fmt.Sprintf(str, params))
 			}))
-			return undoFunc(undo), err
 		},
 		func(ratio float64) (undoFunc, error) {
 			initial, err := memlimit.SetGoMemLimitWithOpts(memlimit.WithRatio(ratio))

extension/cgroupruntimeextension/go.mod

@@ -1,10 +1,11 @@
 module github.com/open-telemetry/opentelemetry-collector-contrib/extension/cgroupruntimeextension
 
-go 1.22.0
+go 1.22.4
 
 require (
 	github.com/KimMachineGun/automemlimit v0.6.1
 	github.com/containerd/cgroups/v3 v3.0.5
+	github.com/rdforte/gomaxecs v1.1.0
 	github.com/stretchr/testify v1.10.0
 	go.opentelemetry.io/collector/component v0.116.1-0.20241220212031-7c2639723f67
 	go.opentelemetry.io/collector/component/componenttest v0.116.1-0.20241220212031-7c2639723f67

extension/cgroupruntimeextension/integration_test.go

@@ -11,6 +11,8 @@ import (
 	"context"
 	"fmt"
 	"math"
+	"net/http"
+	"net/http/httptest"
 	"os"
 	"path"
 	"path/filepath"
@@ -30,6 +32,7 @@ import (
 
 const (
 	defaultCgroup2Path = "/sys/fs/cgroup"
+	ecsMetadataUri     = "ECS_CONTAINER_METADATA_URI_V4"
 )
 
 // checkCgroupSystem skips the test if is not run in a cgroupv2 system
@@ -63,6 +66,26 @@ func cgroupMaxCpu(filename string) (quota int64, period uint64, err error) {
 	return quota, period, err
 }
 
+func testServerECSMetadata(t *testing.T, containerCPU, taskCPU int) *httptest.Server {
+	t.Helper()
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", func(w http.ResponseWriter, _ *http.Request) {
+		_, err := w.Write([]byte(fmt.Sprintf(`{"Limits":{"CPU":%d},"DockerId":"container-id"}`, containerCPU)))
+		assert.NoError(t, err)
+	})
+	mux.HandleFunc("/task", func(w http.ResponseWriter, _ *http.Request) {
+		_, err := w.Write([]byte(fmt.Sprintf(
+			`{"Containers":[{"DockerId":"container-id","Limits":{"CPU":%d}}],"Limits":{"CPU":%d}}`,
+			containerCPU,
+			taskCPU,
+		)))
+		assert.NoError(t, err)
+	})
+
+	return httptest.NewServer(mux)
+}
+
 func TestCgroupV2SudoIntegration(t *testing.T) {
 	checkCgroupSystem(t)
 	pointerInt64 := func(val int64) *int64 {
@@ -81,6 +104,7 @@ func TestCgroupV2SudoIntegration(t *testing.T) {
 		config             *Config
 		expectedGoMaxProcs int
 		expectedGoMemLimit int64
+		setECSMetadataURI  bool
 	}{
 		{
 			name:            "90% the max cgroup memory and 12 GOMAXPROCS",
@@ -144,6 +168,71 @@ func TestCgroupV2SudoIntegration(t *testing.T) {
 			// 134217728 * 0.1
 			expectedGoMemLimit: 13421772,
 		},
+		{
+			name:            "AWS ECS 90% the max cgroup memory and 12 GOMAXPROCS",
+			cgroupCpuQuota:  pointerInt64(100000),
+			cgroupCpuPeriod: 8000,
+			// 128 Mb
+			cgroupMaxMemory: 134217728,
+			config: &Config{
+				GoMaxProcs: GoMaxProcsConfig{
+					Enabled: true,
+				},
+				GoMemLimit: GoMemLimitConfig{
+					Enabled: true,
+					Ratio:   0.9,
+				},
+			},
+			// 100000 / 8000
+			expectedGoMaxProcs: 12,
+			// 134217728 * 0.9
+			expectedGoMemLimit: 120795955,
+			setECSMetadataURI:  true,
+		},
+		{
+			name:            "AWS ECS 50% of the max cgroup memory and 1 GOMAXPROCS",
+			cgroupCpuQuota:  pointerInt64(100000),
+			cgroupCpuPeriod: 100000,
+			// 128 Mb
+			cgroupMaxMemory: 134217728,
+			config: &Config{
+				GoMaxProcs: GoMaxProcsConfig{
+					Enabled: true,
+				},
+				GoMemLimit: GoMemLimitConfig{
+					Enabled: true,
+					Ratio:   0.5,
+				},
+			},
+			// 100000 / 100000
+			expectedGoMaxProcs: 1,
+			// 134217728 * 0.5
+			expectedGoMemLimit: 67108864,
+			setECSMetadataURI:  true,
+		},
+		{
+			name:            "AWS ECS 10% of the max cgroup memory, max cpu, default GOMAXPROCS",
+			cgroupCpuQuota:  nil,
+			cgroupCpuPeriod: 100000,
+			// 128 Mb
+			cgroupMaxMemory: 134217728,
+			config: &Config{
+				GoMaxProcs: GoMaxProcsConfig{
+					Enabled: true,
+				},
+				GoMemLimit: GoMemLimitConfig{
+					Enabled: true,
+					Ratio:   0.1,
+				},
+			},
+			// GOMAXPROCS is set to the value of  `cpu.max / cpu.period`
+			// If cpu.max is set to max, GOMAXPROCS should not be
+			// modified
+			expectedGoMaxProcs: runtime.GOMAXPROCS(-1),
+			// 134217728 * 0.1
+			expectedGoMemLimit: 13421772,
+			setECSMetadataURI:  true,
+		},
 	}
 
 	cgroupPath, err := cgroup2.PidGroupPath(os.Getpid())
@@ -198,12 +287,25 @@ func TestCgroupV2SudoIntegration(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
+			// if running in ECS environment, set the ECS metedata URI environment variable
+			// to get the Cgroup CPU quota from the httptest server
+			cleanECS := func() {}
+			if test.setECSMetadataURI {
+				server := testServerECSMetadata(t, test.expectedGoMaxProcs*1024, test.expectedGoMaxProcs*1024)
+				os.Setenv(ecsMetadataUri, server.URL)
+				cleanECS = func() {
+					server.Close()
+					os.Unsetenv(ecsMetadataUri)
+				}
+			}
+
 			// restore startup cgroup initial resource values
 			t.Cleanup(func() {
 				debug.SetMemoryLimit(initialGoMem)
 				runtime.GOMAXPROCS(initialGoProcs)
 				memoryCgroupCleanUp()
 				cpuCgroupCleanUp()
+				cleanECS()
 			})
 
 			err = manager.Update(&cgroup2.Resources{