Synthetic Monitoring

data := map[string]interface{}{
	"is_docker":          u.cfg.DockerMode,
	"hostname":           u.cfg.Hostname(),
	"platform":           platform,
	"architecture":       runtime.GOARCH,
	"agent_version":      p.Version,
	"collector_version":  version.GetCollectorVersion(),
	"agent_status":       p.AgentStatus,
	"collector_status":   p.CollectorStatus,
	"last_error_message": p.CollectorLastError,
}

func (a *Agent) performConfigCheck(agentCtx context.Context) error {
	ctx, cancel := context.WithTimeout(agentCtx, 10*time.Second)
	defer cancel()

	a.logger.Debug("checking for configuration updates")

	// Safely read collector status under lock
	a.collectorMu.Lock()
	params := updater.UpdateCheckerParams{
		Version: a.version,
	}
	if a.collector != nil {
		params.CollectorStatus = "Running"
	} else {
		params.CollectorStatus = "Stopped"
		params.CollectorLastError = a.collectorError
	}
	a.collectorMu.Unlock()

	if a.isRunning.Load() {
		params.AgentStatus = "Running"
	} else {
		params.AgentStatus = "Stopped"
	}

	a.logger.Debugf("Checking for updates with params: %+v", params)
}

req, err := http.NewRequestWithContext(reqCtx, "POST", u.cfg.ConfigUpdateURL, bytes.NewBuffer(jsonData))
if err != nil {
	return false, nil, fmt.Errorf("failed to create request: %w", err)
}

req.Header.Set("Content-Type", "application/json")
if u.cfg.APIKey != "" {
	req.Header.Set("Authorization", u.cfg.APIKey)
}

resp, respErr := u.client.Do(req)
if respErr != nil {
	return false, nil, fmt.Errorf("failed to fetch config updates: %w", respErr)
}
defer resp.Body.Close()

func GetAgentConfigUpdaterURL(collectorEndpoint string) string {
	const fallbackURL = "https://api.kloudmate.com/agents/config-check"

	u, _ := url.Parse(collectorEndpoint)
	host := u.Hostname()
	parts := strings.Split(host, ".")

	if len(parts) < 2 {
		return fallbackURL
	}

	// Extract root domain from collector endpoint
	// e.g., "otel.kloudmate.dev" -> "kloudmate.dev"
	rootDomain := parts[len(parts)-2] + "." + parts[len(parts)-1]

	// Build API URL with same domain
	updateURL := url.URL{
		Scheme: u.Scheme,
		Host:   "api." + rootDomain,
		Path:   "/agents/config-check",
	}

	return updateURL.String()
}

func (a *Agent) runConfigUpdateChecker(ctx context.Context) {
	if a.cfg.ConfigUpdateURL == "" {
		a.logger.Debug("config update URL not configured, skipping update checks")
		return
	}
	if a.cfg.ConfigCheckInterval <= 0 {
		a.logger.Debug("config check interval not set, skipping update checks")
		return
	}
	a.logger.Infow("config update checker started",
		"updateURL", a.cfg.ConfigUpdateURL,
		"intervalSeconds", a.cfg.ConfigCheckInterval,
	)
	ticker := time.NewTicker(time.Duration(a.cfg.ConfigCheckInterval) * time.Second)
	defer ticker.Stop()

	// Perform first check immediately
	if err := a.performConfigCheck(ctx); err != nil {
		a.logger.Errorf("Periodic config check failed: %v", err)
	}

	for {
		select {
		case <-ticker.C:
			if err := a.performConfigCheck(ctx); err != nil {
				a.logger.Errorf("Periodic config check failed: %v", err)
			}
		case <-a.shutdownSignal:
			a.logger.Info("config update checker stopping")
			return
		case <-ctx.Done():
			a.logger.Info("config update checker stopping")
			return
		}
	}
}

runErr := collector.Run(ctx)
if runErr != nil {
	a.collectorError = runErr.Error()
	a.logger.Errorw("collector run loop exited with error", "error", runErr)
} else {
	a.collectorError = ""
	a.logger.Info("collector run loop exited normally")
}

a.collectorMu.Lock()
params := updater.UpdateCheckerParams{
	Version: a.version,
}
if a.collector != nil {
	params.CollectorStatus = "Running"
} else {
	params.CollectorStatus = "Stopped"
	params.CollectorLastError = a.collectorError  // Reported to API
}
a.collectorMu.Unlock()