Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

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.go
index 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.Mutex
server *localingest.Server
done 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, done
e.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.done
e.server, e.done = nil, nil
diff --git a/collector-builder/exporter/beaconjsonexporter/beaconingestextension/extension_windows_test.go b/collector-builder/exporter/beaconjsonexporter/beaconingestextension/extension_windows_test.go
index 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.cfg
second := 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.go
new file mode 100644
index 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.Second
diff --git a/collector-builder/exporter/beaconjsonexporter/beaconingestextension/listen_windows.go b/collector-builder/exporter/beaconjsonexporter/beaconingestextension/listen_windows.go
new file mode 100644
index 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