Patch: memory fix

Author: curusarn

.github/workflows/betterstack-docker.yml

@@ -0,0 +1,95 @@
+name: BetterStack Docker Build and Push
+
+on:
+  push:
+    branches:
+      - main
+      - betterstack-*
+    tags:
+      - 'v*'
+  pull_request:
+    branches:
+      - main
+
+env:
+  IMAGE_NAME: betterstack/beyla
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+      
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+
+      - name: Apply memory leak fix
+        run: |
+          echo "Applying BetterStack memory leak fix..."
+          patch -p1 < fix-memory-leak-minimal.patch
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to DockerHub
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.IMAGE_NAME }}
+          tags: |
+            # For main branch, use 'latest' tag
+            type=raw,value=latest,enable={{is_default_branch}}
+            # For version tags, use the version
+            type=ref,event=tag
+            # For branches, use branch name
+            type=ref,event=branch
+            # SHA prefix for all builds
+            type=sha,prefix={{branch}}-,format=short
+
+      - name: Build and test
+        run: |
+          make build
+          make test
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+          build-args: |
+            VERSION=${{ github.ref_name }}
+            COMMIT=${{ github.sha }}
+
+      - name: Update Docker Hub description
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+        uses: peter-evans/dockerhub-description@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+          repository: ${{ env.IMAGE_NAME }}
+          short-description: "BetterStack's fork of Beyla with memory leak fixes"
+          readme-filepath: ./README_BETTERSTACK.md

README_BETTERSTACK.md

@@ -0,0 +1,65 @@
+# BetterStack Beyla Fork
+
+This is BetterStack's fork of [Grafana Beyla](https://github.com/grafana/beyla) with critical fixes for production use.
+
+## Why This Fork?
+
+This fork includes essential patches that fix memory leaks in Beyla when monitoring high-connection processes. The patches have been submitted upstream but are critical for production use.
+
+## Patches Applied
+
+### Memory Leak Fix
+- **Issue**: Unbounded array growth when tracking processes with many ephemeral connections
+- **Fix**: Deduplicates ports and caps the maximum tracked ports per process
+- **Impact**: Prevents OOM kills when monitoring load generators or high-traffic clients
+- **PR**: [Pending upstream submission]
+
+## Docker Images
+
+Pre-built Docker images with our patches are available at:
+```
+docker pull betterstack/beyla:latest
+```
+
+## Usage
+
+This fork is a drop-in replacement for the official Beyla. Simply replace your image reference:
+
+```yaml
+# Before
+image: grafana/beyla:latest
+
+# After  
+image: betterstack/beyla:latest
+```
+
+## Building From Source
+
+```bash
+# Clone this repository
+git clone [email protected]:BetterStackHQ/beyla.git
+cd beyla
+
+# The patch is automatically applied during CI/CD
+# To apply manually:
+patch -p1 < fix-memory-leak-minimal.patch
+
+# Build
+make build
+```
+
+## Staying Up-to-Date
+
+This fork is regularly synced with upstream Grafana Beyla. Our CI/CD automatically:
+1. Applies our patches
+2. Runs all tests
+3. Builds multi-architecture Docker images
+4. Pushes to DockerHub
+
+## Contributing
+
+Issues and PRs related to our patches should be opened in this fork. For general Beyla issues, please contribute upstream at [grafana/beyla](https://github.com/grafana/beyla).
+
+## License
+
+This fork maintains the same Apache 2.0 license as the original Beyla project.

fix-memory-leak-minimal.patch

@@ -0,0 +1,48 @@
+--- a/vendor/go.opentelemetry.io/obi/pkg/components/discover/watcher_proc.go
++++ b/vendor/go.opentelemetry.io/obi/pkg/components/discover/watcher_proc.go
+@@ -469,6 +469,11 @@ func processAgeFunc(pid int32) time.Duration {
+ 	return time.Since(createTime)
+ }
+ 
++const (
++	// Maximum ports to track per process to prevent memory exhaustion
++	maxPortsPerProcess = 1000
++)
++
+ // fetchProcessConnections returns a map with the PIDs of all the running processes as a key,
+ // and the open ports for the given process as a value
+ func fetchProcessPorts(scanPorts bool) (map[PID]ProcessAttrs, error) {
+@@ -488,11 +493,29 @@ func fetchProcessPorts(scanPorts bool) (map[PID]ProcessAttrs, error) {
+ 			log.Debug("can't get connections for process. Skipping", "pid", pid, "error", err)
+ 			continue
+ 		}
+-		var openPorts []uint32
+-		// TODO: Cap the size of this array, leaking client ephemeral ports will cause this to grow very long
++		
++		// Use a map to deduplicate ports first
++		portSet := make(map[uint32]bool)
+ 		for _, conn := range conns {
+-			openPorts = append(openPorts, conn.Laddr.Port)
++			portSet[conn.Laddr.Port] = true
++		}
++		
++		// Convert to array with size limit to prevent memory exhaustion
++		var openPorts []uint32
++		cappedPorts := false
++		for port := range portSet {
++			if len(openPorts) >= maxPortsPerProcess {
++				cappedPorts = true
++				break
++			}
++			openPorts = append(openPorts, port)
+ 		}
++		
++		// Log at debug level when we cap ports (not warn to avoid log spam)
++		if cappedPorts {
++			log.Debug("capped ports for process to prevent memory exhaustion",
++				"pid", pid, "total_unique_ports", len(portSet), "tracked_ports", len(openPorts))
++		}
++		
+ 		processes[PID(pid)] = ProcessAttrs{pid: PID(pid), openPorts: openPorts, processAge: time.Duration(0)}
+ 	}
+ 	return processes, nil