feat: enhance observability metrics collection and reporting

- Updated BuildSnapshot function to include OpenResty metrics.
- Enhanced BuildTrafficReport to utilize managed OpenResty metrics.
- Introduced new functions for parsing access logs in both JSON and combined formats.
- Added tests for traffic report generation from combined access logs.
- Implemented local observability metrics collection from OpenResty.
- Created Lua scripts for OpenResty to gather observability data.
- Updated configuration documentation to include new observability port and settings.
- Added support for OpenResty observability in the server configuration.

atsf_agent/cmd/agent/main.go

@@ -33,14 +33,15 @@ func main() {
 	cfg.NginxVersion = nginx.DetectVersion(
 		context.Background(),
 		nginx.ExecutorOptions{
-			NginxPath:       cfg.OpenrestyPath,
-			DockerBinary:    cfg.DockerBinary,
-			ContainerName:   cfg.OpenrestyContainerName,
-			Image:           cfg.OpenrestyDockerImage,
-			MainConfigPath:  cfg.MainConfigPath,
-			RouteConfigPath: cfg.RouteConfigPath,
-			CertDir:         cfg.CertDir,
-			NginxCertDir:    cfg.OpenrestyCertDir,
+			NginxPath:                  cfg.OpenrestyPath,
+			DockerBinary:               cfg.DockerBinary,
+			ContainerName:              cfg.OpenrestyContainerName,
+			Image:                      cfg.OpenrestyDockerImage,
+			MainConfigPath:             cfg.MainConfigPath,
+			RouteConfigPath:            cfg.RouteConfigPath,
+			CertDir:                    cfg.CertDir,
+			NginxCertDir:               cfg.OpenrestyCertDir,
+			OpenrestyObservabilityPort: cfg.OpenrestyObservabilityPort,
 		},
 	)
 	slog.Info("agent config loaded",
@@ -59,20 +60,22 @@ func main() {
 		runtimeRouteConfigPath = nginx.DockerRouteConfigPath
 	}
 	runtimeManager := &nginx.Manager{
-		MainConfigPath:         cfg.MainConfigPath,
-		RouteConfigPath:        cfg.RouteConfigPath,
-		RuntimeRouteConfigPath: runtimeRouteConfigPath,
-		CertDir:                cfg.CertDir,
-		NginxCertDir:           cfg.OpenrestyCertDir,
+		MainConfigPath:             cfg.MainConfigPath,
+		RouteConfigPath:            cfg.RouteConfigPath,
+		RuntimeRouteConfigPath:     runtimeRouteConfigPath,
+		CertDir:                    cfg.CertDir,
+		NginxCertDir:               cfg.OpenrestyCertDir,
+		OpenrestyObservabilityPort: cfg.OpenrestyObservabilityPort,
 		Executor: nginx.NewExecutor(nginx.ExecutorOptions{
-			NginxPath:       cfg.OpenrestyPath,
-			DockerBinary:    cfg.DockerBinary,
-			ContainerName:   cfg.OpenrestyContainerName,
-			Image:           cfg.OpenrestyDockerImage,
-			MainConfigPath:  cfg.MainConfigPath,
-			RouteConfigPath: cfg.RouteConfigPath,
-			CertDir:         cfg.CertDir,
-			NginxCertDir:    cfg.OpenrestyCertDir,
+			NginxPath:                  cfg.OpenrestyPath,
+			DockerBinary:               cfg.DockerBinary,
+			ContainerName:              cfg.OpenrestyContainerName,
+			Image:                      cfg.OpenrestyDockerImage,
+			MainConfigPath:             cfg.MainConfigPath,
+			RouteConfigPath:            cfg.RouteConfigPath,
+			CertDir:                    cfg.CertDir,
+			NginxCertDir:               cfg.OpenrestyCertDir,
+			OpenrestyObservabilityPort: cfg.OpenrestyObservabilityPort,
 		}),
 	}
 	runner := &agent.Runner{

atsf_agent/internal/agent/runner.go

@@ -312,8 +312,9 @@ func (r *Runner) nodePayload(nodeID string) protocol.NodePayload {
 		openrestyStatus = protocol.OpenrestyStatusUnknown
 	}
 	profile := observability.BuildProfile(r.Config, r.StateStore)
-	metricSnapshot := observability.BuildSnapshot(r.Config, r.StateStore)
-	trafficReport := observability.BuildTrafficReport(r.Config, r.StateStore)
+	managedOpenRestyMetrics := observability.CollectManagedOpenRestyMetrics(r.Config)
+	metricSnapshot := observability.BuildSnapshot(r.Config, r.StateStore, managedOpenRestyMetrics)
+	trafficReport := observability.BuildTrafficReport(r.Config, r.StateStore, managedOpenRestyMetrics)
 	healthEvents := observability.BuildHealthEvents(snapshot)
 	return protocol.NodePayload{
 		NodeID:           nodeID,

atsf_agent/internal/config/config.go

@@ -17,49 +17,52 @@ const (
 	defaultCertDirRelativePath           = "etc/nginx/certs"
 	defaultDockerStateRelativePath       = "var/lib/atsflare/agent-state.json"
 	defaultDockerOpenRestyCertDir        = "/etc/nginx/atsflare-certs"
+	defaultOpenRestyObservabilityPort    = 18081
 )
 
 type Config struct {
-	ServerURL              string              `json:"server_url"`
-	AgentToken             string              `json:"agent_token"`
-	DiscoveryToken         string              `json:"discovery_token"`
-	NodeName               string              `json:"node_name"`
-	NodeIP                 string              `json:"node_ip"`
-	AgentVersion           string              `json:"-"`
-	NginxVersion           string              `json:"-"`
-	OpenrestyPath          string              `json:"openresty_path"`
-	OpenrestyContainerName string              `json:"openresty_container_name"`
-	OpenrestyDockerImage   string              `json:"openresty_docker_image"`
-	DockerBinary           string              `json:"docker_binary"`
-	DataDir                string              `json:"data_dir"`
-	MainConfigPath         string              `json:"main_config_path"`
-	RouteConfigPath        string              `json:"route_config_path"`
-	CertDir                string              `json:"cert_dir"`
-	OpenrestyCertDir       string              `json:"openresty_cert_dir"`
-	StatePath              string              `json:"state_path"`
-	HeartbeatInterval      MillisecondDuration `json:"heartbeat_interval"`
-	RequestTimeout         MillisecondDuration `json:"request_timeout"`
-	configPath             string
+	ServerURL                  string              `json:"server_url"`
+	AgentToken                 string              `json:"agent_token"`
+	DiscoveryToken             string              `json:"discovery_token"`
+	NodeName                   string              `json:"node_name"`
+	NodeIP                     string              `json:"node_ip"`
+	AgentVersion               string              `json:"-"`
+	NginxVersion               string              `json:"-"`
+	OpenrestyPath              string              `json:"openresty_path"`
+	OpenrestyContainerName     string              `json:"openresty_container_name"`
+	OpenrestyDockerImage       string              `json:"openresty_docker_image"`
+	DockerBinary               string              `json:"docker_binary"`
+	DataDir                    string              `json:"data_dir"`
+	MainConfigPath             string              `json:"main_config_path"`
+	RouteConfigPath            string              `json:"route_config_path"`
+	CertDir                    string              `json:"cert_dir"`
+	OpenrestyCertDir           string              `json:"openresty_cert_dir"`
+	OpenrestyObservabilityPort int                 `json:"openresty_observability_port"`
+	StatePath                  string              `json:"state_path"`
+	HeartbeatInterval          MillisecondDuration `json:"heartbeat_interval"`
+	RequestTimeout             MillisecondDuration `json:"request_timeout"`
+	configPath                 string
 }
 
 type configFile struct {
-	ServerURL              string              `json:"server_url"`
-	AgentToken             string              `json:"agent_token"`
-	DiscoveryToken         string              `json:"discovery_token"`
-	NodeName               string              `json:"node_name"`
-	NodeIP                 string              `json:"node_ip"`
-	OpenrestyPath          string              `json:"openresty_path"`
-	OpenrestyContainerName string              `json:"openresty_container_name"`
-	OpenrestyDockerImage   string              `json:"openresty_docker_image"`
-	DockerBinary           string              `json:"docker_binary"`
-	DataDir                string              `json:"data_dir"`
-	MainConfigPath         string              `json:"main_config_path"`
-	RouteConfigPath        string              `json:"route_config_path"`
-	CertDir                string              `json:"cert_dir"`
-	OpenrestyCertDir       string              `json:"openresty_cert_dir"`
-	StatePath              string              `json:"state_path"`
-	HeartbeatInterval      MillisecondDuration `json:"heartbeat_interval"`
-	RequestTimeout         MillisecondDuration `json:"request_timeout"`
+	ServerURL                  string              `json:"server_url"`
+	AgentToken                 string              `json:"agent_token"`
+	DiscoveryToken             string              `json:"discovery_token"`
+	NodeName                   string              `json:"node_name"`
+	NodeIP                     string              `json:"node_ip"`
+	OpenrestyPath              string              `json:"openresty_path"`
+	OpenrestyContainerName     string              `json:"openresty_container_name"`
+	OpenrestyDockerImage       string              `json:"openresty_docker_image"`
+	DockerBinary               string              `json:"docker_binary"`
+	DataDir                    string              `json:"data_dir"`
+	MainConfigPath             string              `json:"main_config_path"`
+	RouteConfigPath            string              `json:"route_config_path"`
+	CertDir                    string              `json:"cert_dir"`
+	OpenrestyCertDir           string              `json:"openresty_cert_dir"`
+	OpenrestyObservabilityPort int                 `json:"openresty_observability_port"`
+	StatePath                  string              `json:"state_path"`
+	HeartbeatInterval          MillisecondDuration `json:"heartbeat_interval"`
+	RequestTimeout             MillisecondDuration `json:"request_timeout"`
 }
 
 func Load(path string) (*Config, error) {
@@ -72,23 +75,24 @@ func Load(path string) (*Config, error) {
 		return nil, err
 	}
 	cfg := &Config{
-		ServerURL:              file.ServerURL,
-		AgentToken:             file.AgentToken,
-		DiscoveryToken:         file.DiscoveryToken,
-		NodeName:               file.NodeName,
-		NodeIP:                 file.NodeIP,
-		OpenrestyPath:          file.OpenrestyPath,
-		OpenrestyContainerName: file.OpenrestyContainerName,
-		OpenrestyDockerImage:   file.OpenrestyDockerImage,
-		DockerBinary:           file.DockerBinary,
-		DataDir:                file.DataDir,
-		MainConfigPath:         file.MainConfigPath,
-		RouteConfigPath:        file.RouteConfigPath,
-		CertDir:                file.CertDir,
-		OpenrestyCertDir:       file.OpenrestyCertDir,
-		StatePath:              file.StatePath,
-		HeartbeatInterval:      file.HeartbeatInterval,
-		RequestTimeout:         file.RequestTimeout,
+		ServerURL:                  file.ServerURL,
+		AgentToken:                 file.AgentToken,
+		DiscoveryToken:             file.DiscoveryToken,
+		NodeName:                   file.NodeName,
+		NodeIP:                     file.NodeIP,
+		OpenrestyPath:              file.OpenrestyPath,
+		OpenrestyContainerName:     file.OpenrestyContainerName,
+		OpenrestyDockerImage:       file.OpenrestyDockerImage,
+		DockerBinary:               file.DockerBinary,
+		DataDir:                    file.DataDir,
+		MainConfigPath:             file.MainConfigPath,
+		RouteConfigPath:            file.RouteConfigPath,
+		CertDir:                    file.CertDir,
+		OpenrestyCertDir:           file.OpenrestyCertDir,
+		OpenrestyObservabilityPort: file.OpenrestyObservabilityPort,
+		StatePath:                  file.StatePath,
+		HeartbeatInterval:          file.HeartbeatInterval,
+		RequestTimeout:             file.RequestTimeout,
 	}
 	cfg.configPath = path
 	applyDefaults(cfg, filepath.Dir(path))
@@ -144,6 +148,9 @@ func applyDefaults(cfg *Config, baseDir string) {
 			cfg.OpenrestyCertDir = defaultDockerOpenRestyCertDir
 		}
 	}
+	if cfg.OpenrestyObservabilityPort <= 0 {
+		cfg.OpenrestyObservabilityPort = defaultOpenRestyObservabilityPort
+	}
 	if cfg.HeartbeatInterval <= 0 {
 		cfg.HeartbeatInterval = MillisecondDuration(10 * time.Second)
 	}
@@ -198,6 +205,9 @@ func validate(cfg *Config) error {
 	if cfg.NodeIP == "" {
 		return errors.New("node_ip 不能为空")
 	}
+	if cfg.OpenrestyObservabilityPort <= 0 || cfg.OpenrestyObservabilityPort > 65535 {
+		return errors.New("openresty_observability_port 必须在 1-65535 之间")
+	}
 	return nil
 }
 

atsf_agent/internal/config/config_test.go

@@ -54,6 +54,9 @@ func TestLoadDockerModeUsesManagedPaths(t *testing.T) {
 	if cfg.StatePath != filepath.Join(dir, "data", defaultDockerStateRelativePath) {
 		t.Fatalf("unexpected state path: %s", cfg.StatePath)
 	}
+	if cfg.OpenrestyObservabilityPort != defaultOpenRestyObservabilityPort {
+		t.Fatalf("unexpected openresty observability port: %d", cfg.OpenrestyObservabilityPort)
+	}
 }
 
 func TestLoadPathModeKeepsExplicitPaths(t *testing.T) {
@@ -94,6 +97,9 @@ func TestLoadPathModeKeepsExplicitPaths(t *testing.T) {
 	if cfg.OpenrestyCertDir != cfg.CertDir {
 		t.Fatalf("expected path mode openresty cert dir to equal cert dir, got %s / %s", cfg.OpenrestyCertDir, cfg.CertDir)
 	}
+	if cfg.OpenrestyObservabilityPort != defaultOpenRestyObservabilityPort {
+		t.Fatalf("unexpected path mode openresty observability port: %d", cfg.OpenrestyObservabilityPort)
+	}
 }
 
 func TestLoadUsesCustomDataDirForGeneratedFiles(t *testing.T) {
@@ -204,6 +210,9 @@ func TestSavePersistsMillisecondsAndOmitsRuntimeVersions(t *testing.T) {
 	if decoded["request_timeout"] != float64(7000) {
 		t.Fatalf("unexpected request timeout: %#v", decoded["request_timeout"])
 	}
+	if decoded["openresty_observability_port"] != float64(defaultOpenRestyObservabilityPort) {
+		t.Fatalf("unexpected observability port: %#v", decoded["openresty_observability_port"])
+	}
 	if _, ok := decoded["nginx_path"]; ok {
 		t.Fatal("legacy nginx_path should not be persisted")
 	}

atsf_agent/internal/nginx/manager.go

@@ -20,6 +20,8 @@ import (
 const CertDirPlaceholder = "__ATSF_CERT_DIR__"
 const RouteConfigPlaceholder = "__ATSF_ROUTE_CONFIG__"
 const AccessLogPlaceholder = "__ATSF_ACCESS_LOG__"
+const LuaDirPlaceholder = "__ATSF_LUA_DIR__"
+const ObservabilityPortPlaceholder = "__ATSF_OBSERVABILITY_PORT__"
 const DockerMainConfigPath = "/usr/local/openresty/nginx/conf/nginx.conf"
 const DockerRouteConfigPath = "/etc/nginx/conf.d/atsflare_routes.conf"
 const DockerAccessLogPath = "/etc/nginx/conf.d/atsflare_access.log"
@@ -97,14 +99,15 @@ func (e *PathExecutor) Restart(ctx context.Context) error {
 }
 
 type DockerExecutor struct {
-	DockerBinary   string
-	ContainerName  string
-	Image          string
-	MainConfigPath string
-	RouteConfigDir string
-	CertDir        string
-	NginxCertDir   string
-	Runner         CommandRunner
+	DockerBinary               string
+	ContainerName              string
+	Image                      string
+	MainConfigPath             string
+	RouteConfigDir             string
+	CertDir                    string
+	NginxCertDir               string
+	OpenrestyObservabilityPort int
+	Runner                     CommandRunner
 }
 
 func (e *DockerExecutor) Test(ctx context.Context) error {
@@ -180,6 +183,7 @@ func (e *DockerExecutor) runContainer(ctx context.Context) error {
 		"--name", e.ContainerName,
 		"-p", "80:80",
 		"-p", "443:443",
+		"-p", fmt.Sprintf("127.0.0.1:%d:%d", e.OpenrestyObservabilityPort, e.OpenrestyObservabilityPort),
 		"-v", fmt.Sprintf("%s:%s", e.MainConfigPath, DockerMainConfigPath),
 		"-v", fmt.Sprintf("%s:/etc/nginx/conf.d", e.RouteConfigDir),
 		"-v", fmt.Sprintf("%s:%s", e.CertDir, e.NginxCertDir),
@@ -194,12 +198,13 @@ func (e *DockerExecutor) runContainer(ctx context.Context) error {
 }
 
 type Manager struct {
-	MainConfigPath         string
-	RouteConfigPath        string
-	RuntimeRouteConfigPath string
-	CertDir                string
-	NginxCertDir           string
-	Executor               Executor
+	MainConfigPath             string
+	RouteConfigPath            string
+	RuntimeRouteConfigPath     string
+	CertDir                    string
+	NginxCertDir               string
+	OpenrestyObservabilityPort int
+	Executor                   Executor
 }
 
 func (m *Manager) Apply(ctx context.Context, mainConfig string, routeConfig string, supportFiles []protocol.SupportFile) error {
@@ -290,6 +295,12 @@ func (m *Manager) CurrentChecksum() (string, error) {
 	if accessLogPath := m.accessLogRuntimePath(); accessLogPath != "" {
 		normalizedMain = strings.ReplaceAll(normalizedMain, accessLogPath, AccessLogPlaceholder)
 	}
+	if luaDir := m.luaRuntimePath(); luaDir != "" {
+		normalizedMain = strings.ReplaceAll(normalizedMain, luaDir, LuaDirPlaceholder)
+	}
+	if m.OpenrestyObservabilityPort > 0 {
+		normalizedMain = strings.ReplaceAll(normalizedMain, fmt.Sprintf("%d", m.OpenrestyObservabilityPort), ObservabilityPortPlaceholder)
+	}
 	normalizedRoute := string(data)
 	if m.NginxCertDir != "" {
 		normalizedRoute = strings.ReplaceAll(normalizedRoute, m.NginxCertDir, CertDirPlaceholder)
@@ -304,14 +315,15 @@ func (m *Manager) CurrentChecksum() (string, error) {
 }
 
 type ExecutorOptions struct {
-	NginxPath       string
-	DockerBinary    string
-	ContainerName   string
-	Image           string
-	MainConfigPath  string
-	RouteConfigPath string
-	CertDir         string
-	NginxCertDir    string
+	NginxPath                  string
+	DockerBinary               string
+	ContainerName              string
+	Image                      string
+	MainConfigPath             string
+	RouteConfigPath            string
+	CertDir                    string
+	NginxCertDir               string
+	OpenrestyObservabilityPort int
 }
 
 func NewExecutor(options ExecutorOptions) Executor {
@@ -335,14 +347,15 @@ func NewExecutor(options ExecutorOptions) Executor {
 		certDir = absDir
 	}
 	return &DockerExecutor{
-		DockerBinary:   options.DockerBinary,
-		ContainerName:  options.ContainerName,
-		Image:          options.Image,
-		MainConfigPath: mainConfigPath,
-		RouteConfigDir: routeConfigDir,
-		CertDir:        certDir,
-		NginxCertDir:   options.NginxCertDir,
-		Runner:         runner,
+		DockerBinary:               options.DockerBinary,
+		ContainerName:              options.ContainerName,
+		Image:                      options.Image,
+		MainConfigPath:             mainConfigPath,
+		RouteConfigDir:             routeConfigDir,
+		CertDir:                    certDir,
+		NginxCertDir:               options.NginxCertDir,
+		OpenrestyObservabilityPort: options.OpenrestyObservabilityPort,
+		Runner:                     runner,
 	}
 }
 
@@ -588,7 +601,11 @@ func (m *Manager) supportFileTargetPath(relativePath string) (string, error) {
 	if strings.TrimSpace(m.CertDir) == "" {
 		return "", errors.New("cert dir 不能为空")
 	}
-	normalizedPath := filepath.Clean(filepath.FromSlash(strings.TrimSpace(relativePath)))
+	candidate := strings.TrimSpace(relativePath)
+	if strings.Contains(candidate, `\`) {
+		candidate = strings.ReplaceAll(candidate, `\`, "/")
+	}
+	normalizedPath := filepath.Clean(filepath.FromSlash(candidate))
 	if normalizedPath == "." || normalizedPath == "" {
 		return "", errors.New("support file path 不能为空")
 	}
@@ -621,6 +638,12 @@ func (m *Manager) renderMainConfig(content string) string {
 	if accessLogPath := m.accessLogRuntimePath(); accessLogPath != "" {
 		rendered = strings.ReplaceAll(rendered, AccessLogPlaceholder, accessLogPath)
 	}
+	if luaDir := m.luaRuntimePath(); luaDir != "" {
+		rendered = strings.ReplaceAll(rendered, LuaDirPlaceholder, luaDir)
+	}
+	if m.OpenrestyObservabilityPort > 0 {
+		rendered = strings.ReplaceAll(rendered, ObservabilityPortPlaceholder, fmt.Sprintf("%d", m.OpenrestyObservabilityPort))
+	}
 	return rendered
 }
 
@@ -639,6 +662,13 @@ func (m *Manager) accessLogRuntimePath() string {
 	return filepath.ToSlash(filepath.Join(filepath.Dir(includePath), "atsflare_access.log"))
 }
 
+func (m *Manager) luaRuntimePath() string {
+	if strings.TrimSpace(m.NginxCertDir) == "" {
+		return ""
+	}
+	return filepath.ToSlash(m.NginxCertDir)
+}
+
 func checksum(content string) string {
 	sum := sha256.Sum256([]byte(content))
 	return hex.EncodeToString(sum[:])

atsf_agent/internal/nginx/manager_test.go

@@ -210,14 +210,15 @@ func TestDockerExecutorRunContainerMountsManagedFiles(t *testing.T) {
 	certDir := filepath.Clean("/tmp/managed/certs")
 	runner := &fakeRunner{}
 	executor := &DockerExecutor{
-		DockerBinary:   "docker",
-		ContainerName:  "atsflare-openresty",
-		Image:          "openresty/openresty:alpine",
-		MainConfigPath: mainConfigPath,
-		RouteConfigDir: routeConfigDir,
-		CertDir:        certDir,
-		NginxCertDir:   "/etc/nginx/atsflare-certs",
-		Runner:         runner,
+		DockerBinary:               "docker",
+		ContainerName:              "atsflare-openresty",
+		Image:                      "openresty/openresty:alpine",
+		MainConfigPath:             mainConfigPath,
+		RouteConfigDir:             routeConfigDir,
+		CertDir:                    certDir,
+		NginxCertDir:               "/etc/nginx/atsflare-certs",
+		OpenrestyObservabilityPort: 18081,
+		Runner:                     runner,
 	}
 
 	if err := executor.runContainer(context.Background()); err != nil {
@@ -233,6 +234,7 @@ func TestDockerExecutorRunContainerMountsManagedFiles(t *testing.T) {
 		"--name", "atsflare-openresty",
 		"-p", "80:80",
 		"-p", "443:443",
+		"-p", "127.0.0.1:18081:18081",
 		"-v", mainConfigPath + ":" + DockerMainConfigPath,
 		"-v", routeConfigDir + ":/etc/nginx/conf.d",
 		"-v", certDir + ":/etc/nginx/atsflare-certs",
@@ -253,14 +255,15 @@ func TestDockerExecutorRecreatesContainerOnStartup(t *testing.T) {
 		},
 	}
 	executor := &DockerExecutor{
-		DockerBinary:   "docker",
-		ContainerName:  "atsflare-openresty",
-		Image:          "openresty/openresty:alpine",
-		MainConfigPath: filepath.Clean("/tmp/nginx.conf"),
-		RouteConfigDir: filepath.Clean("/tmp/routes"),
-		CertDir:        filepath.Clean("/tmp/certs"),
-		NginxCertDir:   "/etc/nginx/atsflare-certs",
-		Runner:         runner,
+		DockerBinary:               "docker",
+		ContainerName:              "atsflare-openresty",
+		Image:                      "openresty/openresty:alpine",
+		MainConfigPath:             filepath.Clean("/tmp/nginx.conf"),
+		RouteConfigDir:             filepath.Clean("/tmp/routes"),
+		CertDir:                    filepath.Clean("/tmp/certs"),
+		NginxCertDir:               "/etc/nginx/atsflare-certs",
+		OpenrestyObservabilityPort: 18081,
+		Runner:                     runner,
 	}
 
 	if err := executor.EnsureRuntime(context.Background(), true); err != nil {
@@ -279,13 +282,14 @@ func TestDockerExecutorRecreatesContainerOnStartup(t *testing.T) {
 
 func TestNewExecutorUsesAbsoluteDockerMountPath(t *testing.T) {
 	executor := NewExecutor(ExecutorOptions{
-		DockerBinary:    "docker",
-		ContainerName:   "atsflare-openresty",
-		Image:           "openresty/openresty:alpine",
-		MainConfigPath:  "./data/etc/nginx/nginx.conf",
-		RouteConfigPath: "./data/etc/nginx/conf.d/atsflare_routes.conf",
-		CertDir:         "./data/etc/nginx/certs",
-		NginxCertDir:    "/etc/nginx/atsflare-certs",
+		DockerBinary:               "docker",
+		ContainerName:              "atsflare-openresty",
+		Image:                      "openresty/openresty:alpine",
+		MainConfigPath:             "./data/etc/nginx/nginx.conf",
+		RouteConfigPath:            "./data/etc/nginx/conf.d/atsflare_routes.conf",
+		CertDir:                    "./data/etc/nginx/certs",
+		NginxCertDir:               "/etc/nginx/atsflare-certs",
+		OpenrestyObservabilityPort: 18081,
 	})
 
 	dockerExecutor, ok := executor.(*DockerExecutor)

atsf_agent/internal/observability/collector.go

@@ -40,7 +40,7 @@ func BuildProfile(cfg *config.Config, stateStore *state.Store) *protocol.NodeSys
 	return profile
 }
 
-func BuildSnapshot(cfg *config.Config, stateStore *state.Store) *protocol.NodeMetricSnapshot {
+func BuildSnapshot(cfg *config.Config, stateStore *state.Store, managed *managedOpenRestyMetrics) *protocol.NodeMetricSnapshot {
 	now := time.Now().UTC()
 	metric := &protocol.NodeMetricSnapshot{
 		CapturedAtUnix: now.Unix(),
@@ -56,6 +56,11 @@ func BuildSnapshot(cfg *config.Config, stateStore *state.Store) *protocol.NodeMe
 
 	metric.NetworkRxBytes, metric.NetworkTxBytes = readLinuxNetworkTotals()
 	metric.DiskReadBytes, metric.DiskWriteBytes = readLinuxDiskTotals()
+	if managed != nil {
+		metric.OpenrestyRxBytes = managed.OpenrestyRxBytes
+		metric.OpenrestyTxBytes = managed.OpenrestyTxBytes
+		metric.OpenrestyConnections = managed.OpenrestyConnections
+	}
 
 	if stateStore == nil {
 		return metric

atsf_agent/internal/observability/openresty_local.go

@@ -0,0 +1,129 @@
+package observability
+
+import (
+	"atsflare-agent/internal/config"
+	"atsflare-agent/internal/protocol"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const openRestyObservabilityPath = "/atsflare/observability"
+const openRestyStubStatusPath = "/atsflare/stub_status"
+
+var stubStatusActivePattern = regexp.MustCompile(`Active connections:\s+(\d+)`)
+
+type managedOpenRestyMetrics struct {
+	TrafficReport        *protocol.NodeTrafficReport
+	OpenrestyRxBytes     int64
+	OpenrestyTxBytes     int64
+	OpenrestyConnections int64
+}
+
+type openRestyObservabilityResponse struct {
+	WindowStartedAtUnix int64            `json:"window_started_at_unix"`
+	WindowEndedAtUnix   int64            `json:"window_ended_at_unix"`
+	RequestCount        int64            `json:"request_count"`
+	ErrorCount          int64            `json:"error_count"`
+	UniqueVisitorCount  int64            `json:"unique_visitor_count"`
+	StatusCodes         map[string]int64 `json:"status_codes"`
+	TopDomains          map[string]int64 `json:"top_domains"`
+	SourceCountries     map[string]int64 `json:"source_countries"`
+	OpenrestyRxBytes    int64            `json:"openresty_rx_bytes"`
+	OpenrestyTxBytes    int64            `json:"openresty_tx_bytes"`
+}
+
+func CollectManagedOpenRestyMetrics(cfg *config.Config) *managedOpenRestyMetrics {
+	if cfg == nil || cfg.OpenrestyObservabilityPort <= 0 {
+		return nil
+	}
+
+	baseURL := fmt.Sprintf("http://127.0.0.1:%d", cfg.OpenrestyObservabilityPort)
+	client := &http.Client{Timeout: 1500 * time.Millisecond}
+
+	observabilityResp := openRestyObservabilityResponse{}
+	if err := fetchLocalJSON(client, baseURL+openRestyObservabilityPath, &observabilityResp); err != nil {
+		return nil
+	}
+
+	result := &managedOpenRestyMetrics{
+		TrafficReport: &protocol.NodeTrafficReport{
+			WindowStartedAtUnix: observabilityResp.WindowStartedAtUnix,
+			WindowEndedAtUnix:   observabilityResp.WindowEndedAtUnix,
+			RequestCount:        observabilityResp.RequestCount,
+			ErrorCount:          observabilityResp.ErrorCount,
+			UniqueVisitorCount:  observabilityResp.UniqueVisitorCount,
+			StatusCodes:         normalizeCountMap(observabilityResp.StatusCodes),
+			TopDomains:          normalizeCountMap(observabilityResp.TopDomains),
+			SourceCountries:     normalizeCountMap(observabilityResp.SourceCountries),
+		},
+		OpenrestyRxBytes: observabilityResp.OpenrestyRxBytes,
+		OpenrestyTxBytes: observabilityResp.OpenrestyTxBytes,
+	}
+
+	if text, err := fetchLocalText(client, baseURL+openRestyStubStatusPath); err == nil {
+		result.OpenrestyConnections = parseStubStatusActiveConnections(text)
+	}
+
+	return result
+}
+
+func fetchLocalJSON(client *http.Client, url string, target any) error {
+	resp, err := client.Get(url)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("unexpected local observability status: %s", resp.Status)
+	}
+	return json.NewDecoder(resp.Body).Decode(target)
+}
+
+func fetchLocalText(client *http.Client, url string) (string, error) {
+	resp, err := client.Get(url)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("unexpected local stub status: %s", resp.Status)
+	}
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func parseStubStatusActiveConnections(raw string) int64 {
+	matches := stubStatusActivePattern.FindStringSubmatch(raw)
+	if len(matches) != 2 {
+		return 0
+	}
+	value, err := strconv.ParseInt(matches[1], 10, 64)
+	if err != nil {
+		return 0
+	}
+	return value
+}
+
+func normalizeCountMap(values map[string]int64) map[string]int64 {
+	if len(values) == 0 {
+		return map[string]int64{}
+	}
+	result := make(map[string]int64, len(values))
+	for key, value := range values {
+		key = strings.TrimSpace(key)
+		if key == "" || value <= 0 {
+			continue
+		}
+		result[key] = value
+	}
+	return result
+}

atsf_agent/internal/observability/openresty_local_test.go

@@ -0,0 +1,82 @@
+package observability
+
+import (
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"atsflare-agent/internal/config"
+)
+
+func TestCollectManagedOpenRestyMetrics(t *testing.T) {
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("Listen failed: %v", err)
+	}
+	port := listener.Addr().(*net.TCPAddr).Port
+
+	mux := http.NewServeMux()
+	mux.HandleFunc(openRestyObservabilityPath, func(writer http.ResponseWriter, request *http.Request) {
+		writer.Header().Set("Content-Type", "application/json")
+		_, _ = writer.Write([]byte(`{"window_started_at_unix":1710403200,"window_ended_at_unix":1710403210,"request_count":12,"error_count":2,"unique_visitor_count":5,"status_codes":{"200":10,"502":2},"top_domains":{"app.example.com":9,"api.example.com":3},"source_countries":{},"openresty_rx_bytes":4096,"openresty_tx_bytes":8192}`))
+	})
+	mux.HandleFunc(openRestyStubStatusPath, func(writer http.ResponseWriter, request *http.Request) {
+		_, _ = writer.Write([]byte("Active connections: 7 \nserver accepts handled requests\n 10 10 12 \nReading: 1 Writing: 2 Waiting: 4 \n"))
+	})
+
+	server := httptest.NewUnstartedServer(mux)
+	server.Listener = listener
+	server.Start()
+	defer server.Close()
+
+	metrics := CollectManagedOpenRestyMetrics(&config.Config{
+		OpenrestyObservabilityPort: port,
+	})
+	if metrics == nil || metrics.TrafficReport == nil {
+		t.Fatalf("expected managed openresty metrics, got %+v", metrics)
+	}
+	if metrics.TrafficReport.RequestCount != 12 || metrics.TrafficReport.ErrorCount != 2 {
+		t.Fatalf("unexpected traffic report: %+v", metrics.TrafficReport)
+	}
+	if metrics.OpenrestyRxBytes != 4096 || metrics.OpenrestyTxBytes != 8192 {
+		t.Fatalf("unexpected openresty byte counters: %+v", metrics)
+	}
+	if metrics.OpenrestyConnections != 7 {
+		t.Fatalf("unexpected openresty connections: %+v", metrics)
+	}
+}
+
+func TestParseStubStatusActiveConnections(t *testing.T) {
+	if value := parseStubStatusActiveConnections("Active connections: 19\n"); value != 19 {
+		t.Fatalf("unexpected active connections: %d", value)
+	}
+}
+
+func TestNormalizeCountMapDropsEmptyKeys(t *testing.T) {
+	normalized := normalizeCountMap(map[string]int64{
+		"":                4,
+		" 200 ":           3,
+		"app.example.com": 0,
+	})
+	if len(normalized) != 1 || normalized["200"] != 3 {
+		t.Fatalf("unexpected normalized map: %+v", normalized)
+	}
+}
+
+func TestCollectManagedOpenRestyMetricsHandlesUnavailableEndpoint(t *testing.T) {
+	cfg := &config.Config{OpenrestyObservabilityPort: 1}
+	if metrics := CollectManagedOpenRestyMetrics(cfg); metrics != nil {
+		t.Fatalf("expected nil metrics for unavailable endpoint, got %+v", metrics)
+	}
+}
+
+func TestOpenRestyObservabilityPathsAreStable(t *testing.T) {
+	if !strings.HasPrefix(openRestyObservabilityPath, "/atsflare/") {
+		t.Fatalf("unexpected observability path: %s", openRestyObservabilityPath)
+	}
+	if !strings.HasPrefix(openRestyStubStatusPath, "/atsflare/") {
+		t.Fatalf("unexpected stub status path: %s", openRestyStubStatusPath)
+	}
+}

atsf_agent/internal/observability/traffic.go

@@ -10,6 +10,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"regexp"
 	"sort"
 	"strconv"
 	"strings"
@@ -23,6 +24,8 @@ type accessLogRecord struct {
 	Status     int    `json:"status"`
 }
 
+var combinedAccessLogPattern = regexp.MustCompile(`^(\S+)\s+\S+\s+\S+\s+\[([^\]]+)\]\s+"[^"]*"\s+(\d{3})\s+\S+`)
+
 type trafficAggregate struct {
 	windowStartedAt time.Time
 	windowEndedAt   time.Time
@@ -33,7 +36,10 @@ type trafficAggregate struct {
 	visitors        map[string]struct{}
 }
 
-func BuildTrafficReport(cfg *config.Config, stateStore *state.Store) *protocol.NodeTrafficReport {
+func BuildTrafficReport(cfg *config.Config, stateStore *state.Store, managed *managedOpenRestyMetrics) *protocol.NodeTrafficReport {
+	if managed != nil && managed.TrafficReport != nil && managed.TrafficReport.RequestCount > 0 {
+		return managed.TrafficReport
+	}
 	if cfg == nil || stateStore == nil {
 		return nil
 	}
@@ -115,21 +121,16 @@ func (aggregate *trafficAggregate) consume(line []byte) {
 		return
 	}
 
-	var record accessLogRecord
-	if err := json.Unmarshal([]byte(trimmed), &record); err != nil {
+	record, ok := parseAccessLogRecord(trimmed)
+	if !ok {
 		return
 	}
 
-	timestamp, err := parseAccessLogTime(record.Timestamp)
-	if err != nil {
-		return
+	if aggregate.windowStartedAt.IsZero() || record.Timestamp.Before(aggregate.windowStartedAt) {
+		aggregate.windowStartedAt = record.Timestamp
 	}
-
-	if aggregate.windowStartedAt.IsZero() || timestamp.Before(aggregate.windowStartedAt) {
-		aggregate.windowStartedAt = timestamp
-	}
-	if aggregate.windowEndedAt.IsZero() || timestamp.After(aggregate.windowEndedAt) {
-		aggregate.windowEndedAt = timestamp
+	if aggregate.windowEndedAt.IsZero() || record.Timestamp.After(aggregate.windowEndedAt) {
+		aggregate.windowEndedAt = record.Timestamp
 	}
 
 	aggregate.requestCount++
@@ -147,6 +148,58 @@ func (aggregate *trafficAggregate) consume(line []byte) {
 	}
 }
 
+type parsedAccessLogRecord struct {
+	Timestamp  time.Time
+	Host       string
+	RemoteAddr string
+	Status     int
+}
+
+func parseAccessLogRecord(raw string) (parsedAccessLogRecord, bool) {
+	record, ok := parseJSONAccessLogRecord(raw)
+	if ok {
+		return record, true
+	}
+	return parseCombinedAccessLogRecord(raw)
+}
+
+func parseJSONAccessLogRecord(raw string) (parsedAccessLogRecord, bool) {
+	var record accessLogRecord
+	if err := json.Unmarshal([]byte(raw), &record); err != nil {
+		return parsedAccessLogRecord{}, false
+	}
+	timestamp, err := parseAccessLogTime(record.Timestamp)
+	if err != nil {
+		return parsedAccessLogRecord{}, false
+	}
+	return parsedAccessLogRecord{
+		Timestamp:  timestamp,
+		Host:       strings.TrimSpace(record.Host),
+		RemoteAddr: strings.TrimSpace(record.RemoteAddr),
+		Status:     record.Status,
+	}, true
+}
+
+func parseCombinedAccessLogRecord(raw string) (parsedAccessLogRecord, bool) {
+	matches := combinedAccessLogPattern.FindStringSubmatch(raw)
+	if len(matches) != 4 {
+		return parsedAccessLogRecord{}, false
+	}
+	timestamp, err := parseAccessLogTime(matches[2])
+	if err != nil {
+		return parsedAccessLogRecord{}, false
+	}
+	status, err := strconv.Atoi(matches[3])
+	if err != nil {
+		return parsedAccessLogRecord{}, false
+	}
+	return parsedAccessLogRecord{
+		Timestamp:  timestamp,
+		RemoteAddr: strings.TrimSpace(matches[1]),
+		Status:     status,
+	}, true
+}
+
 func (aggregate *trafficAggregate) report() *protocol.NodeTrafficReport {
 	if aggregate.requestCount == 0 || aggregate.windowStartedAt.IsZero() || aggregate.windowEndedAt.IsZero() {
 		return nil
@@ -165,7 +218,15 @@ func (aggregate *trafficAggregate) report() *protocol.NodeTrafficReport {
 }
 
 func parseAccessLogTime(value string) (time.Time, error) {
-	return time.Parse(time.RFC3339, strings.TrimSpace(value))
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return time.Time{}, errors.New("empty access log time")
+	}
+	timestamp, err := time.Parse(time.RFC3339, trimmed)
+	if err == nil {
+		return timestamp, nil
+	}
+	return time.Parse("02/Jan/2006:15:04:05 -0700", trimmed)
 }
 
 func cloneTrafficCounts(values map[string]int64, limit int) map[string]int64 {

atsf_agent/internal/observability/traffic_test.go

@@ -26,7 +26,7 @@ func TestBuildTrafficReportAggregatesManagedAccessLog(t *testing.T) {
 	}
 
 	stateStore := state.NewStore(filepath.Join(tempDir, "state.json"))
-	report := BuildTrafficReport(&config.Config{RouteConfigPath: routeConfigPath}, stateStore)
+	report := BuildTrafficReport(&config.Config{RouteConfigPath: routeConfigPath}, stateStore, nil)
 	if report == nil {
 		t.Fatal("expected traffic report")
 	}
@@ -48,7 +48,7 @@ func TestBuildTrafficReportAggregatesManagedAccessLog(t *testing.T) {
 		t.Fatalf("unexpected access log offset: %d", snapshot.AccessLogOffset)
 	}
 
-	secondReport := BuildTrafficReport(&config.Config{RouteConfigPath: routeConfigPath}, stateStore)
+	secondReport := BuildTrafficReport(&config.Config{RouteConfigPath: routeConfigPath}, stateStore, nil)
 	if secondReport != nil {
 		t.Fatalf("expected no report without appended lines, got %+v", secondReport)
 	}
@@ -70,8 +70,40 @@ func TestBuildTrafficReportResetsOffsetAfterTruncate(t *testing.T) {
 		t.Fatalf("Save failed: %v", err)
 	}
 
-	report := BuildTrafficReport(&config.Config{RouteConfigPath: routeConfigPath}, stateStore)
+	report := BuildTrafficReport(&config.Config{RouteConfigPath: routeConfigPath}, stateStore, nil)
 	if report == nil || report.RequestCount != 1 {
 		t.Fatalf("expected one request after truncate reset, got %+v", report)
 	}
 }
+
+func TestBuildTrafficReportParsesCombinedAccessLog(t *testing.T) {
+	tempDir := t.TempDir()
+	routeConfigPath := filepath.Join(tempDir, "conf.d", "atsflare_routes.conf")
+	if err := os.MkdirAll(filepath.Dir(routeConfigPath), 0o755); err != nil {
+		t.Fatalf("MkdirAll failed: %v", err)
+	}
+	logPath := filepath.Join(filepath.Dir(routeConfigPath), "atsflare_access.log")
+	content := []byte(
+		"10.0.0.1 - - [14/Mar/2026:08:00:00 +0000] \"GET / HTTP/1.1\" 200 123 \"-\" \"curl/8.0\"\n" +
+			"10.0.0.2 - - [14/Mar/2026:08:00:05 +0000] \"GET /healthz HTTP/1.1\" 502 64 \"-\" \"curl/8.0\"\n" +
+			"10.0.0.1 - - [14/Mar/2026:08:00:10 +0000] \"GET /api HTTP/1.1\" 200 256 \"-\" \"curl/8.0\"\n",
+	)
+	if err := os.WriteFile(logPath, content, 0o644); err != nil {
+		t.Fatalf("WriteFile failed: %v", err)
+	}
+
+	stateStore := state.NewStore(filepath.Join(tempDir, "state.json"))
+	report := BuildTrafficReport(&config.Config{RouteConfigPath: routeConfigPath}, stateStore, nil)
+	if report == nil {
+		t.Fatal("expected traffic report from combined access log")
+	}
+	if report.RequestCount != 3 || report.ErrorCount != 1 || report.UniqueVisitorCount != 2 {
+		t.Fatalf("unexpected combined log counters: %+v", report)
+	}
+	if report.StatusCodes["200"] != 2 || report.StatusCodes["502"] != 1 {
+		t.Fatalf("unexpected combined log status codes: %+v", report.StatusCodes)
+	}
+	if len(report.TopDomains) != 0 {
+		t.Fatalf("expected combined access log to omit top domains when host is unavailable, got %+v", report.TopDomains)
+	}
+}