Release v0.30.0

.gitignore

@@ -2,6 +2,7 @@
 /node_modules
 /.pnp
 .pnp.js
+.pnpm-store/
 
 # testing
 /coverage

agent/internal/agent/agent.go

@@ -127,6 +127,9 @@ func NewAgent(
 
 type MetricsSender interface {
 	SendSystemStats(stats *health.SystemStats, collectedAt time.Time) error
+	SendAgentStats(stats *health.AgentProcessStats, collectedAt time.Time) error
+	SendContainerStats(stats []container.ResourceStats, collectedAt time.Time) error
+	SendPrometheusMetrics(data []byte, extraLabels map[string]string) error
 }
 
 func (a *Agent) GetState() AgentState {

agent/internal/agent/drift.go

@@ -575,13 +575,19 @@ func (a *Agent) updateTraefik() error {
 	}
 
 	needsRestart := false
+	metricsRestart, err := traefik.EnsureMetricsConfig()
+	if err != nil {
+		return fmt.Errorf("failed to ensure Traefik metrics config: %w", err)
+	}
+	needsRestart = metricsRestart
+
 	if len(tcpPorts) > 0 || len(udpPorts) > 0 {
 		log.Printf("[reconcile] ensuring L4 entry points: %d TCP, %d UDP", len(tcpPorts), len(udpPorts))
-		var err error
-		needsRestart, err = traefik.EnsureEntryPoints(tcpPorts, udpPorts)
+		entryPointsRestart, err := traefik.EnsureEntryPoints(tcpPorts, udpPorts)
 		if err != nil {
 			return fmt.Errorf("failed to ensure entry points: %w", err)
 		}
+		needsRestart = needsRestart || entryPointsRestart
 	}
 
 	log.Printf("[reconcile] updating Traefik routes (HTTP: %d, TCP: %d, UDP: %d)", len(expectedHttpRoutes), len(tcpRoutes), len(udpRoutes))

agent/internal/agent/reporting.go

@@ -53,6 +53,20 @@ func (a *Agent) BuildStatusReport(includeResources bool) *agenthttp.StatusReport
 				if err := a.MetricsSender.SendSystemStats(systemStats, collectedAt); err != nil {
 					log.Printf("[metrics] failed to send system stats: %v", err)
 				}
+				agentStats, err := health.CollectAgentProcessStats()
+				if err != nil {
+					log.Printf("[metrics] failed to collect agent stats: %v", err)
+				} else if err := a.MetricsSender.SendAgentStats(agentStats, collectedAt); err != nil {
+					log.Printf("[metrics] failed to send agent stats: %v", err)
+				}
+				containerStats, err := container.CollectResourceStats()
+				if err != nil {
+					log.Printf("[metrics] failed to collect container stats: %v", err)
+					return
+				}
+				if err := a.MetricsSender.SendContainerStats(containerStats, collectedAt); err != nil {
+					log.Printf("[metrics] failed to send container stats: %v", err)
+				}
 			}()
 		}
 		report.NetworkHealth = health.CollectNetworkHealth("wg0")

agent/internal/agent/run.go

@@ -2,13 +2,22 @@ package agent
 
 import (
 	"context"
+	"fmt"
+	"io"
 	"log"
+	"net/http"
 	"time"
 
 	"techulus/cloud-agent/internal/container"
 	"techulus/cloud-agent/internal/serverless"
 )
 
+const (
+	traefikMetricsURL      = "http://127.0.0.1:9100/metrics"
+	traefikMetricsInterval = 15 * time.Second
+	traefikMetricsMaxBytes = 8 * 1024 * 1024
+)
+
 func (a *Agent) Run(ctx context.Context) {
 	if a.Config.RegistryURL != "" && a.Config.RegistryUsername != "" && a.Config.RegistryPassword != "" {
 		if err := container.Login(a.Config.RegistryURL, a.Config.RegistryUsername, a.Config.RegistryPassword, a.Config.RegistryInsecure); err != nil {
@@ -33,6 +42,10 @@ func (a *Agent) Run(ctx context.Context) {
 		a.TraefikLogCollector.Start()
 	}
 
+	if a.IsProxy && a.MetricsSender != nil {
+		go a.TraefikMetricsLoop(ctx)
+	}
+
 	if a.IsProxy {
 		gateway := serverless.NewGateway(a)
 		if err := gateway.Start(ctx); err != nil {
@@ -81,6 +94,58 @@ func (a *Agent) Run(ctx context.Context) {
 	}
 }
 
+func (a *Agent) TraefikMetricsLoop(ctx context.Context) {
+	ticker := time.NewTicker(traefikMetricsInterval)
+	defer ticker.Stop()
+
+	if err := a.ForwardTraefikMetrics(ctx); err != nil {
+		log.Printf("[traefik-metrics] initial scrape failed: %v", err)
+	}
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			if err := a.ForwardTraefikMetrics(ctx); err != nil {
+				log.Printf("[traefik-metrics] scrape failed: %v", err)
+			}
+		}
+	}
+}
+
+func (a *Agent) ForwardTraefikMetrics(ctx context.Context) error {
+	if a.MetricsSender == nil {
+		return nil
+	}
+
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, traefikMetricsURL, nil)
+	if err != nil {
+		return err
+	}
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	response, err := client.Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		return fmt.Errorf("unexpected status %d", response.StatusCode)
+	}
+
+	body, err := io.ReadAll(io.LimitReader(response.Body, traefikMetricsMaxBytes))
+	if err != nil {
+		return err
+	}
+
+	return a.MetricsSender.SendPrometheusMetrics(body, map[string]string{
+		"job":       "traefik",
+		"server_id": a.Config.ServerID,
+	})
+}
+
 func (a *Agent) StatusReportLoop(ctx context.Context) {
 	a.reportStatus("startup")