The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
beacon_ingest: on Windows, keep the collector up when the pipe's name is taken
Claudeea600a02df70
diff --git a/collector-builder/exporter/beaconjsonexporter/beaconingestextension/extension.go b/collector-builder/exporter/beaconjsonexporter/beaconingestextension/extension.goindex 00b85853..e4d89a87 100644--- a/collector-builder/exporter/beaconjsonexporter/beaconingestextension/extension.go+++ b/collector-builder/exporter/beaconjsonexporter/beaconingestextension/extension.go@@ -15,6 +15,7 @@ import ("fmt""net""sync"+ "time""go.opentelemetry.io/collector/component""go.opentelemetry.io/collector/component/componentstatus"@@ -38,6 +39,9 @@ type ingest struct {mu sync.Mutexserver *localingest.Serverdone chan error+ // stopRetry and retried are set while Start is still waiting to listen (see listenRetries).+ stopRetry chan struct{}+ retried chan struct{}}func newIngest(cfg *Config, logger *zap.Logger) *ingest {@@ -53,10 +57,17 @@ func newIngest(cfg *Config, logger *zap.Logger) *ingest {}}-// Start creates the socket or pipe and serves it in the background. A socket another running-// collector still answers on, a non-socket at the path, or a pipe that already exists (another-// collector, or an account that took the name first) fails the start: two writers serving one log,-// or a name someone else holds, is a problem to surface, not to work around.+// Start creates the socket or pipe and serves it in the background.+//+// On Unix a socket another running collector still answers on, or a non-socket at the path, fails+// the start: two writers serving one log is a problem to surface, not to work around, and the+// socket's directory is root's, so nobody else can hold the name.+//+// On Windows the pipe's name is in a namespace every account can create in, so an account that+// takes it first must not be able to keep the whole collector down (the beaconjson exporter and the+// OTLP receivers with it). There a failed listen is reported as a recoverable error and retried+// every listenRetryInterval until it succeeds or the collector stops; meanwhile hooks refuse the+// impostor's pipe, which is not owned by SYSTEM or Administrators, and spool their events.func (e *ingest) Start(_ context.Context, host component.Host) error {if !asymptoteobserve.RuntimeLogAccessRestricted(e.cfg.LogPath) {// Harmless -- the log is simply also writable directly -- but not what install sets up,@@ -65,9 +76,51 @@ func (e *ingest) Start(_ context.Context, host component.Host) error {zap.String("log_path", e.cfg.LogPath))}l, err := e.listen(e.socketPath())- if err != nil {- return fmt.Errorf("beacon_ingest: listen on %s: %w", e.socketPath(), err)+ if err == nil {+ e.serve(host, l)+ return nil+ }+ err = fmt.Errorf("beacon_ingest: listen on %s: %w", e.socketPath(), err)+ if !listenRetries {+ return err+ }+ e.logger.Error("beacon_ingest cannot listen yet; hooks spool their events until it can", zap.Error(err))+ if host != nil {+ componentstatus.ReportStatus(host, componentstatus.NewRecoverableErrorEvent(err))+ }+ stop, retried := make(chan struct{}), make(chan struct{})+ e.mu.Lock()+ e.stopRetry, e.retried = stop, retried+ e.mu.Unlock()+ go e.retryListen(host, stop, retried)+ return nil+}++// retryListen listens again every listenRetryInterval until it succeeds or stop is closed.+func (e *ingest) retryListen(host component.Host, stop <-chan struct{}, retried chan<- struct{}) {+ defer close(retried)+ ticker := time.NewTicker(listenRetryInterval)+ defer ticker.Stop()+ for {+ select {+ case <-stop:+ return+ case <-ticker.C:+ }+ l, err := e.listen(e.socketPath())+ if err != nil {+ continue+ }+ e.serve(host, l)+ if host != nil {+ componentstatus.ReportStatus(host, componentstatus.NewEvent(componentstatus.StatusOK))+ }+ return}+}++// serve serves l in the background until Shutdown or a serve error.+func (e *ingest) serve(host component.Host, l localingest.Listener) {server := &localingest.Server{Append: e.append,LogPath: e.cfg.LogPath,@@ -104,12 +157,19 @@ func (e *ingest) Start(_ context.Context, host component.Host) error {e.server, e.done = server, donee.mu.Unlock()e.logger.Info("beacon_ingest listening", zap.String("socket", e.socketPath()), zap.String("log_path", e.cfg.LogPath))- return nil}// Shutdown stops serving, waits for connections in progress to finish their writes, and removes// the socket, so hooks find no socket and spool until the collector is back.func (e *ingest) Shutdown(context.Context) error {+ e.mu.Lock()+ stop, retried := e.stopRetry, e.retried+ e.stopRetry, e.retried = nil, nil+ e.mu.Unlock()+ if stop != nil {+ close(stop)+ <-retried // after this nothing else starts serving+ }e.mu.Lock()server, done := e.server, e.donee.server, e.done = nil, nildiff --git a/collector-builder/exporter/beaconjsonexporter/beaconingestextension/extension_windows_test.go b/collector-builder/exporter/beaconjsonexporter/beaconingestextension/extension_windows_test.goindex 190229ec..5a61fd5f 100644--- a/collector-builder/exporter/beaconjsonexporter/beaconingestextension/extension_windows_test.go+++ b/collector-builder/exporter/beaconjsonexporter/beaconingestextension/extension_windows_test.go@@ -106,13 +106,69 @@ func TestEventsSentToThePipeLandInTheLogUnderTheSendersAccount(t *testing.T) {}}-func TestASecondCollectorCannotServeTheSamePipe(t *testing.T) {+// Anyone can create a pipe's name, so a collector that finds its pipe taken -- by another+// collector, or an account that got there first -- starts anyway, so the rest of the collector+// keeps running, and serves the pipe as soon as the name is free.+func TestACollectorWhosePipeIsTakenServesItOnceItIsFree(t *testing.T) {+ prev := listenRetryInterval+ listenRetryInterval = 20 * time.Millisecond+ t.Cleanup(func() { listenRetryInterval = prev })++ f := startOnPipe(t)+ cfg := *f.ext.cfg+ second := newIngest(&cfg, zap.NewNop())+ if err := second.Start(context.Background(), nil); err != nil {+ t.Fatalf("Start with the pipe taken = %v; the collector must keep running", err)+ }+ t.Cleanup(func() { _ = second.Shutdown(context.Background()) })+ second.mu.Lock()+ serving := second.server != nil+ second.mu.Unlock()+ if serving {+ t.Fatal("the second collector claims a pipe the first one serves")+ }++ if err := f.ext.Shutdown(context.Background()); err != nil {+ t.Fatal(err)+ }+ deadline := time.Now().Add(5 * time.Second)+ for {+ if _, err := f.client.Send([][]byte{winEvent(t, 1)}); err == nil {+ break+ } else if time.Now().After(deadline) {+ t.Fatalf("the second collector never took the freed pipe: %v", err)+ }+ time.Sleep(20 * time.Millisecond)+ }+}++// Shutdown stops a collector still waiting for its pipe, and it never serves afterwards.+func TestShutdownStopsWaitingForThePipe(t *testing.T) {+ prev := listenRetryInterval+ listenRetryInterval = 20 * time.Millisecond+ t.Cleanup(func() { listenRetryInterval = prev })+f := startOnPipe(t)cfg := *f.ext.cfgsecond := newIngest(&cfg, zap.NewNop())- if err := second.Start(context.Background(), nil); err == nil {- _ = second.Shutdown(context.Background())- t.Fatal("a second collector started on a pipe another one serves")+ if err := second.Start(context.Background(), nil); err != nil {+ t.Fatal(err)+ }+ if err := second.Shutdown(context.Background()); err != nil {+ t.Fatal(err)+ }+ if err := f.ext.Shutdown(context.Background()); err != nil {+ t.Fatal(err)+ }+ time.Sleep(100 * time.Millisecond)+ second.mu.Lock()+ serving := second.server != nil+ second.mu.Unlock()+ if serving {+ t.Fatal("a collector that was shut down went on to serve the pipe")+ }+ if err := f.client.Probe(); !errors.Is(err, localingest.ErrNoSocket) {+ t.Fatalf("Probe = %v, want ErrNoSocket", err)}}diff --git a/collector-builder/exporter/beaconjsonexporter/beaconingestextension/listen_unix.go b/collector-builder/exporter/beaconjsonexporter/beaconingestextension/listen_unix.gonew file mode 100644index 00000000..d43d8df8--- /dev/null+++ b/collector-builder/exporter/beaconjsonexporter/beaconingestextension/listen_unix.go@@ -0,0 +1,11 @@+//go:build !windows++package beaconingestextension++import "time"++// listenRetries is false on Unix: the socket's directory belongs to root, so a failed listen is a+// real conflict to surface (see Start), not a name someone else took first.+const listenRetries = false++var listenRetryInterval = 5 * time.Seconddiff --git a/collector-builder/exporter/beaconjsonexporter/beaconingestextension/listen_windows.go b/collector-builder/exporter/beaconjsonexporter/beaconingestextension/listen_windows.gonew file mode 100644index 00000000..71d2d5b3--- /dev/null+++ b/collector-builder/exporter/beaconjsonexporter/beaconingestextension/listen_windows.go@@ -0,0 +1,12 @@+//go:build windows++package beaconingestextension++import "time"++// listenRetries is true on Windows, where any account can create the pipe's name first (see Start).+const listenRetries = true++// listenRetryInterval is how often a collector that could not create its pipe tries again; tests+// shorten it.+var listenRetryInterval = 5 * time.Second