Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
feat: stream docker daemon events to arcanes event log (#3862)
Kyle Mendell2a61718a3af9
diff --git a/backend/api/api.go b/backend/api/api.goindex a89d5bffc..5e292f499 100644--- a/backend/api/api.go+++ b/backend/api/api.go@@ -449,5 +449,5 @@ func registerHandlersInternal(api huma.API, deps HandlerDeps, handlerAppCtx handdeps.Webhook.RegisterRoutes(api)deps.Vulnerability.RegisterRoutes(api, handlerAppCtx)deps.Dashboard.RegisterRoutes(api)- handlers.RegisterStream(api, deps.Dashboard.Handler(), deps.Activity.Handler(), deps.Environment.Handler())+ handlers.RegisterStream(api, deps.Dashboard.Handler(), deps.Activity.Handler(), deps.Environment.Handler(), deps.Event.Service())}diff --git a/backend/api/handlers/stream.go b/backend/api/handlers/stream.goindex f16fa2e77..326433a82 100644--- a/backend/api/handlers/stream.go+++ b/backend/api/handlers/stream.go@@ -12,6 +12,7 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/activity""github.com/getarcaneapp/arcane/backend/v2/internal/dashboard""github.com/getarcaneapp/arcane/backend/v2/internal/environment"+ "github.com/getarcaneapp/arcane/backend/v2/internal/event""github.com/getarcaneapp/arcane/backend/v2/internal/middleware""github.com/getarcaneapp/arcane/backend/v2/pkg/authz""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/handlerutil"@@ -19,6 +20,7 @@ import (activitytypes "github.com/getarcaneapp/arcane/types/v2/activity"dashboardtypes "github.com/getarcaneapp/arcane/types/v2/dashboard"environmenttypes "github.com/getarcaneapp/arcane/types/v2/environment"+ eventtypes "github.com/getarcaneapp/arcane/types/v2/event"streamtypes "github.com/getarcaneapp/arcane/types/v2/stream""go.getarcane.app/streams/agg")@@ -36,13 +38,14 @@ const (// StreamHandler multiplexes every live feed onto one connection.type StreamHandler struct {+ events *event.EventServicedashboard *dashboard.DashboardHandleractivity *activity.ActivityHandlerenvironment *environment.EnvironmentHandler}type StreamClientInput struct {- Channels string `query:"channels" doc:"Comma-separated channels to subscribe to: environments, dashboard, activities"`+ Channels string `query:"channels" doc:"Comma-separated channels to subscribe to: environments, dashboard, activities, events"`DebugAllGood bool `query:"debugAllGood" default:"false" doc:"Debug mode for the dashboard channel: force an empty action item list"`Limit int `query:"limit" default:"0" doc:"Maximum activities to include in each activities-channel snapshot"`}@@ -55,8 +58,10 @@ func RegisterStream(dashboardHandler *dashboard.DashboardHandler,activityHandler *activity.ActivityHandler,environmentHandler *environment.EnvironmentHandler,+ eventService *event.EventService,) {h := &StreamHandler{+ events: eventService,dashboard: dashboardHandler,activity: activityHandler,environment: environmentHandler,@@ -67,7 +72,7 @@ func RegisterStream(Method: http.MethodGet,Path: "/stream",Summary: "Multiplexed client stream",- Description: "Streams the requested channels (environments, dashboard, activities) over a single JSON-lines connection",+ Description: "Streams the requested channels (environments, dashboard, activities, events) over a single JSON-lines connection",Tags: []string{"Stream"},Security: handlerutil.DefaultOperationSecurity(),// Ungated: each channel applies its own permission check below, and a@@ -177,11 +182,20 @@ func (h *StreamHandler) producersForInternal(ps *authz.PermissionSet, input *Str}}+ if requested[streamtypes.ChannelEvents] && ps.Allows(authz.PermEventsRead, "") {+ producers = append(producers, forwardStreamChannelInternal(+ streamtypes.ChannelEvents,+ func(channel string, event eventtypes.StreamEvent) streamtypes.Event {+ return streamtypes.Event{Channel: channel, EventLog: &event, Timestamp: event.Timestamp}+ },+ h.events.RunStreamProducer,+ ))+ }return producers}func parseStreamChannelsInternal(raw string) map[string]bool {- channels := make(map[string]bool, 3)+ channels := make(map[string]bool, 4)for name := range strings.SplitSeq(raw, ",") {if trimmed := strings.TrimSpace(strings.ToLower(name)); trimmed != "" {channels[trimmed] = truediff --git a/backend/go.sum b/backend/go.sumindex c180e1f93..5d97a1305 100644--- a/backend/go.sum+++ b/backend/go.sum@@ -738,8 +738,6 @@ go.getarcane.app/builds v0.4.1 h1:R8iEgTf9+NDtI1IEzF2R3Mn+v6AGUqwCMs7CEFpVRZk=go.getarcane.app/builds v0.4.1/go.mod h1:vSWYulIelS9m91mPpvaN+orZ4/A20eGGcynP892eMkg=go.getarcane.app/docker/convert v0.3.1 h1:VcC2gtTFtGBrHTSBd0RodA0u+aerRAYVJIah7p6BNbE=go.getarcane.app/docker/convert v0.3.1/go.mod h1:9ResEOrcsXh6ksRE5MMYnAFJ2STeJzj6zz1wCOP0mTs=-go.getarcane.app/kit v0.1.1 h1:EN3s6J2FvpJOULwm7wESr8CC0FC9eMgCnW9nQGEqcY0=-go.getarcane.app/kit v0.1.1/go.mod h1:oiH4hLowxfQYFtmldyk/y79XYBHYfzgd86MrSQS9UEg=go.getarcane.app/kit v0.2.0 h1:3PPHo5nHuns1vjqmCMFPFdnmbH/qQOserONCba/gBi4=go.getarcane.app/kit v0.2.0/go.mod h1:TGqQCbAJs3ldzkFncXZ93wTVSDhAMQlqyNdVO2CNjIk=go.getarcane.app/streams v0.4.3 h1:Rzg6xCWzYmD4IN+GiKYmAc8HqCgVIq/sQ4DC3OxiZ1o=diff --git a/backend/internal/bootstrap/router_bootstrap.go b/backend/internal/bootstrap/router_bootstrap.goindex 198ed3957..b016f78d4 100644--- a/backend/internal/bootstrap/router_bootstrap.go+++ b/backend/internal/bootstrap/router_bootstrap.go@@ -262,7 +262,16 @@ func newRouter(p RouterParams) (*echo.Echo, *edge.TunnelServer) {// Register public webhook trigger endpoint before auth middleware (token in URL is the sole auth)api.RegisterWebhookTrigger(apiGroup, deps.Webhook.Service(), handlerAppCtx)federated.RegisterFederatedTokenExchange(apiGroup, deps.Federated)- deps.Event.RegisterAgentRoutes(apiGroup)+ deps.Event.RegisterAgentRoutes(apiGroup, func(ctx context.Context, token string) (string, error) {+ env, err := deps.Environment.Service().ResolveEnvironmentByAccessToken(ctx, token)+ if err != nil {+ return "", err+ }+ if env == nil || !env.Enabled || env.ID == "0" {+ return "", nil+ }+ return env.ID, nil+ })permissionMatcher := authz.NewPermissionMatcher()diff --git a/backend/internal/container/service.go b/backend/internal/container/service.goindex 6a37daf56..3100c917f 100644--- a/backend/internal/container/service.go+++ b/backend/internal/container/service.go@@ -148,6 +148,7 @@ func (s *ContainerService) pullRedeployImageInternal(ctx context.Context, dockerpullOptions = client.ImagePullOptions{}}+ defer s.eventService.BeginDockerResourceSuppressionWindow("image", "", imageName)()reader, pullErr := dockerClient.ImagePull(pullCtx, imageName, pullOptions)if pullErr != nil && image.ShouldRetryAnonymousPull(pullOptions, pullErr) {slog.WarnContext(ctx, "container recreate image pull failed with registry auth; retrying anonymously",@@ -194,6 +195,7 @@ func (s *ContainerService) pullRedeployImageInternal(ctx context.Context, docker}func (s *ContainerService) prepareContainerForRedeployInternal(ctx context.Context, dockerClient *client.Client, containerID, containerName, backupName string, wasRunning bool, user common.User) error {+ s.eventService.MarkDockerExpectation("container", containerID, containerName)if containerName != "" {if _, err := dockerClient.ContainerRename(ctx, containerID, client.ContainerRenameOptions{NewName: backupName}); err != nil {s.eventService.LogErrorEvent(ctx, event.EventTypeContainerError, "container", containerID, containerName, user.ID, user.Username, "0", err, database.JSON{@@ -231,6 +233,7 @@ func (s *ContainerService) prepareContainerForRedeployInternal(ctx context.Conte}func (s *ContainerService) restoreContainerAfterRedeployFailureInternal(ctx context.Context, dockerClient *client.Client, containerID, containerName, backupName, failedStep string, wasRunning bool, user common.User) {+ s.eventService.MarkDockerExpectation("container", containerID, containerName)if wasRunning {if _, startErr := dockerClient.ContainerStart(ctx, containerID, client.ContainerStartOptions{}); startErr != nil {s.eventService.LogErrorEvent(ctx, event.EventTypeContainerError, "container", containerID, containerName, user.ID, user.Username, "0", startErr, database.JSON{@@ -270,6 +273,7 @@ func (s *ContainerService) restoreAutoRemoveContainerAfterStartFailureInternal(coriginalConfig.Hostname = ""}+ defer s.eventService.BeginDockerResourceSuppressionWindow("container", "", containerName)()createResp, err := libarcane.ContainerCreateWithCompatibilityForAPIVersion(ctx, dockerClient, client.ContainerCreateOptions{Config: &originalConfig,HostConfig: containerInfo.HostConfig,@@ -284,6 +288,7 @@ func (s *ContainerService) restoreAutoRemoveContainerAfterStartFailureInternal(creturn errors.WrapIf(err, "failed to recreate original auto-remove container")}+ defer s.eventService.BeginDockerResourceSuppressionWindow("container", createResp.ID, containerName)()if _, err := dockerClient.ContainerStart(ctx, createResp.ID, client.ContainerStartOptions{}); err != nil {s.eventService.LogErrorEvent(ctx, event.EventTypeContainerError, "container", createResp.ID, containerName, user.ID, user.Username, "0", err, database.JSON{"action": "redeploy",@@ -308,6 +313,7 @@ func (s *ContainerService) restoreAutoRemoveContainerAfterStartFailureInternal(cfunc (s *ContainerService) rollbackFailedReplacementStartInternal(ctx context.Context, dockerClient *client.Client, containerInfo container.InspectResponse, replacementID, action, backupName string, stopAfterCreate, wasRunning bool, apiVersion string, startErr error, user common.User) error {containerName := strings.TrimPrefix(containerInfo.Name, "/")+ s.eventService.MarkDockerExpectation("container", replacementID, containerName)var cleanupErr errorif _, removeErr := dockerClient.ContainerRemove(ctx, replacementID, client.ContainerRemoveOptions{Force: true}); removeErr != nil {cleanupErr = errors.WrapIf(removeErr, "failed to remove replacement container")@@ -357,6 +363,7 @@ func (s *ContainerService) runContainerLifecycleActionInternal(ctx context.Conteslog.WarnContext(ctx, "could not log container action", "action", cfg.action, "error", err)}+ defer s.eventService.BeginDockerResourceSuppressionWindow("container", containerID, "")()err = cfg.runContainerAction(dockerClient)if err != nil {s.eventService.LogErrorEvent(ctx, event.EventTypeContainerError, "container", containerID, "", user.ID, user.Username, "0", err, database.JSON{"action": cfg.action})@@ -663,6 +670,7 @@ func (s *ContainerService) recreateContainerInternal(ctx context.Context, docker// original. Only a start failure can still lose the original.stopAfterCreate := wasRunning && containerInfo.HostConfig != nil && containerInfo.HostConfig.AutoRemove+ defer s.eventService.BeginDockerResourceSuppressionWindow("container", containerID, containerName)()backupName := buildRedeployBackupNameInternal(containerName, containerID)if err := s.prepareContainerForRedeployInternal(ctx, dockerClient, containerID, containerName, backupName, wasRunning && !stopAfterCreate, user); err != nil {return "", err@@ -672,6 +680,7 @@ func (s *ContainerService) recreateContainerInternal(ctx context.Context, dockernewConfig.Hostname = ""}+ defer s.eventService.BeginDockerResourceSuppressionWindow("container", "", newName)()createResp, err := libarcane.ContainerCreateWithCompatibilityForAPIVersion(ctx, dockerClient, client.ContainerCreateOptions{Config: newConfig,HostConfig: newHostConfig,@@ -688,6 +697,8 @@ func (s *ContainerService) recreateContainerInternal(ctx context.Context, dockerreturn "", errors.WrapIf(err, "failed to recreate container")}+ defer s.eventService.BeginDockerResourceSuppressionWindow("container", createResp.ID, newName)()+if stopAfterCreate {if _, err := dockerClient.ContainerStop(ctx, containerID, client.ContainerStopOptions{Timeout: new(30)}); err != nil {if _, removeErr := dockerClient.ContainerRemove(ctx, createResp.ID, client.ContainerRemoveOptions{Force: true}); removeErr != nil {@@ -1200,6 +1211,10 @@ func (s *ContainerService) DeleteContainer(ctx context.Context, containerID stri}}+ defer s.eventService.BeginDockerResourceSuppressionWindow("container", containerID, "")()+ for _, volumeName := range volumesToRemove {+ defer s.eventService.BeginDockerResourceSuppressionWindow("volume", volumeName, volumeName)()+ }_, err = dockerClient.ContainerRemove(ctx, containerID, client.ContainerRemoveOptions{Force: force,RemoveVolumes: removeVolumes,@@ -1255,6 +1270,7 @@ func (s *ContainerService) CreateContainer(ctx context.Context, config *containepullCtx, pullCancel := context.WithTimeout(ctx, timeouts.GetDuration(settings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull))defer pullCancel()+ defer s.eventService.BeginDockerResourceSuppressionWindow("image", "", config.Image)()reader, pullErr := dockerClient.ImagePull(pullCtx, config.Image, pullOptions)if pullErr != nil {if errors.Is(pullCtx.Err(), context.DeadlineExceeded) {@@ -1276,6 +1292,7 @@ func (s *ContainerService) CreateContainer(ctx context.Context, config *containe}}+ defer s.eventService.BeginDockerResourceSuppressionWindow("container", "", containerName)()resp, err := libarcane.ContainerCreateWithCompatibility(ctx, dockerClient, client.ContainerCreateOptions{Config: config,HostConfig: hostConfig,@@ -1287,6 +1304,7 @@ func (s *ContainerService) CreateContainer(ctx context.Context, config *containereturn nil, errors.WrapIf(err, "failed to create container")}+ defer s.eventService.BeginDockerResourceSuppressionWindow("container", resp.ID, containerName)()metadata := database.JSON{"action": "create","containerId": resp.ID,diff --git a/backend/internal/container/service_test.go b/backend/internal/container/service_test.goindex f8bf95389..e78fe7a10 100644--- a/backend/internal/container/service_test.go+++ b/backend/internal/container/service_test.go@@ -511,3 +511,46 @@ func TestBuildEditNetworkingConfigInternal(t *testing.T) {require.NoError(t, err)require.Nil(t, out)}++func TestRecreateContainerDaemonCorrelationInternal(t *testing.T) {+ db := setupProjectTestDBInternal(t)+ events := event.NewEventService(db, nil, nil)+ observed := make(chan string, 8)+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ path := dockerTestPathInternal(r.URL.Path)+ id, name := "old-id", "web"+ if path == "/containers/create" {+ id = ""+ }+ if path == "/containers/new-id/start" {+ id = "new-id"+ }+ if !events.ShouldSuppressDaemonEvent("container", id, name, "") {+ t.Errorf("missing correlation before Docker mutation %s", path)+ }+ if events.ShouldSuppressDaemonEvent("container", "unrelated", "other", "") {+ t.Errorf("unrelated container suppressed during %s", path)+ }+ observed <- path+ if path == "/containers/create" {+ w.Header().Set("Content-Type", "application/json")+ w.WriteHeader(http.StatusCreated)+ if err := json.NewEncoder(w).Encode(map[string]any{"Id": "new-id", "Warnings": []string{}}); err != nil {+ t.Errorf("encode container creation response: %v", err)+ }+ return+ }+ w.WriteHeader(http.StatusNoContent)+ }))+ t.Cleanup(server.Close)+ dockerClient := newTestDockerClientInternal(t, server)+ svc := NewContainerService(events, nil, nil, nil, nil)+ info := container.InspectResponse{ID: "old-id", Name: "/web", State: &container.State{Running: true}, Config: &container.Config{Image: "app:latest"}, HostConfig: &container.HostConfig{}}+ id, err := svc.recreateContainerInternal(t.Context(), dockerClient, info, "redeploy", "web", info.Config, info.HostConfig, nil, "1.41", event.EventTypeContainerDeploy, common.SystemUser)+ require.NoError(t, err)+ require.Equal(t, "new-id", id)+ require.Len(t, observed, 5)+ require.Equal(t, []string{"/containers/old-id/rename", "/containers/old-id/stop", "/containers/create", "/containers/new-id/start", "/containers/old-id"}, []string{<-observed, <-observed, <-observed, <-observed, <-observed})+ require.True(t, events.ShouldSuppressDaemonEvent("container", "old-id", "", ""))+ require.True(t, events.ShouldSuppressDaemonEvent("container", "new-id", "", ""))+}diff --git a/backend/internal/di/di_test.go b/backend/internal/di/di_test.goindex d0d3d4644..0ca0e721f 100644--- a/backend/internal/di/di_test.go+++ b/backend/internal/di/di_test.go@@ -2,8 +2,18 @@ package diimport ("context"+ "encoding/json/v2"+ "github.com/getarcaneapp/arcane/backend/v2/internal/actors"+ "github.com/libtnb/sqlite"+ "github.com/moby/moby/api/types/events"+ "go.uber.org/fx/fxtest"+ "gorm.io/gorm""net/http"+ "net/http/httptest"+ "strings"+ "sync""testing"+ "time""github.com/getarcaneapp/arcane/backend/v2/internal/activity""github.com/getarcaneapp/arcane/backend/v2/internal/apikey"@@ -133,3 +143,69 @@ func TestOptionsValidate(t *testing.T) {)require.NoError(t, err)}++func TestDockerEventLifecycleInternal(t *testing.T) {+ for _, mode := range []string{"manager", "agent", "edge"} {+ t.Run(mode, func(t *testing.T) {+ streamStopped := make(chan struct{})+ var stopped sync.Once+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if strings.HasSuffix(r.URL.Path, "/_ping") {+ w.Header().Set("Api-Version", "1.56")+ return+ }+ if !strings.HasSuffix(r.URL.Path, "/events") {+ http.NotFound(w, r)+ return+ }+ w.Header().Set("Content-Type", "application/json")+ err := json.MarshalWrite(w, events.Message{Type: events.ContainerEventType, Action: events.ActionStart, Actor: events.Actor{ID: "daemon-container", Attributes: map[string]string{"name": "external"}}})+ if err != nil {+ return+ }+ w.(http.Flusher).Flush()+ <-r.Context().Done()+ stopped.Do(func() { close(streamStopped) })+ }))+ t.Cleanup(server.Close)+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})+ require.NoError(t, err)+ sqlDB, err := db.DB()+ require.NoError(t, err)+ sqlDB.SetMaxOpenConns(1)+ t.Cleanup(func() { require.NoError(t, sqlDB.Close()) })+ require.NoError(t, db.AutoMigrate(&event.Event{}))+ databaseDB := &database.DB{DB: db}+ cfg := &config.Config{DockerHost: server.URL, AgentMode: mode != "manager", EdgeAgent: mode == "edge"}+ lifecycle := fxtest.NewLifecycle(t)+ runtime, err := actors.NewRuntime(t.Context(), lifecycle)+ require.NoError(t, err)+ eventService := event.NewEventService(databaseDB, cfg, nil)+ provideDockerClientServiceInternal(t.Context(), lifecycle, runtime, databaseDB, cfg, nil, eventService)+ t.Cleanup(func() {+ ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)+ defer cancel()+ require.NoError(t, lifecycle.Stop(ctx))+ })+ require.NoError(t, lifecycle.Start(t.Context()))+ require.Eventually(t, func() bool {+ var count int64+ return db.Model(&event.Event{}).Count(&count).Error == nil && count == 1+ }, 2*time.Second, 10*time.Millisecond)+ var record event.Event+ require.NoError(t, db.First(&record).Error)+ require.Equal(t, event.EventTypeContainerStart, record.Type)+ require.Equal(t, "System", *record.Username)+ require.Equal(t, "0", *record.EnvironmentID)+ require.Equal(t, "docker", record.Metadata["source"])+ stopCtx, cancel := context.WithTimeout(context.Background(), 3*time.Second)+ defer cancel()+ require.NoError(t, lifecycle.Stop(stopCtx))+ select {+ case <-streamStopped:+ case <-stopCtx.Done():+ t.Fatal("Docker event stream was not joined")+ }+ })+ }+}diff --git a/backend/internal/di/providers.go b/backend/internal/di/providers.goindex e7bc9ad78..bfcc3f1ec 100644--- a/backend/internal/di/providers.go+++ b/backend/internal/di/providers.go@@ -51,6 +51,8 @@ import ("github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/oidcjwk""github.com/getarcaneapp/arcane/backend/v2/resources"+ "github.com/moby/moby/api/types/events"+ "go.getarcane.app/streams/bus""go.uber.org/fx")@@ -186,20 +188,38 @@ func provideTunnelRegistryInternal(ctx context.Context, lc fx.Lifecycle, runtimereturn registry, nil}-func provideDockerClientServiceInternal(ctx context.Context, lc fx.Lifecycle, actorRuntime *actors.Runtime, db *database.DB, cfg *config.Config, settings *settings.SettingsService) *docker.DockerClientService {- service := docker.NewDockerClientService(ctx, db, cfg, settings)- var runner *actors.Runner+func provideDockerClientServiceInternal(ctx context.Context, lc fx.Lifecycle, actorRuntime *actors.Runtime, db *database.DB, cfg *config.Config, settings *settings.SettingsService, eventService *event.EventService) *docker.DockerClientService {+ service := docker.NewDockerClientService(ctx, db, cfg, settings, bus.WithDroppedEventCallback(func(message events.Message) {+ // Overflow is recovered synchronously, applying backpressure instead of losing log entries.+ eventService.RecordDockerEvent(ctx, message)+ }))+ var runner, logRunner *actors.Runner+ var unsubscribe func()lc.Append(fx.Hook{- OnStart: func(context.Context) error {+ OnStart: func(startCtx context.Context) error {+ run, cleanup := eventService.SubscribeDockerEvents(service.EventBus())+ unsubscribe = cleanupvar err error+ logRunner, err = actors.NewRunner(ctx, actorRuntime, "docker-events", "log", "Docker event log", 3, run)+ if err != nil {+ cleanup()+ return err+ }runner, err = actors.NewRunner(ctx, actorRuntime, "docker-events", "stream", "Docker event watcher", 3, func(runCtx context.Context) error {service.WatchEvents(runCtx)return nil})+ if err != nil {+ err = errors.Combine(err, logRunner.Stop(startCtx))+ cleanup()+ }return err},OnStop: func(stopCtx context.Context) error {- err := runner.Stop(stopCtx)+ err := errors.Combine(runner.Stop(stopCtx), logRunner.Stop(stopCtx))+ if unsubscribe != nil {+ unsubscribe()+ }service.Close()return err},diff --git a/backend/internal/docker/service.go b/backend/internal/docker/service.goindex 22f57042c..4230ec414 100644--- a/backend/internal/docker/service.go+++ b/backend/internal/docker/service.go@@ -53,12 +53,12 @@ type DockerClientService struct {containerListFlight singleflight.Group}-func NewDockerClientService(_ context.Context, db *database.DB, cfg *config.Config, settingsService *settings.SettingsService) *DockerClientService {+func NewDockerClientService(_ context.Context, db *database.DB, cfg *config.Config, settingsService *settings.SettingsService, eventBusOptions ...bus.Option) *DockerClientService {return &DockerClientService{db: db,config: cfg,settingsService: settingsService,- eventBus: bus.NewDockerEventBus(),+ eventBus: bus.NewDockerEventBus(eventBusOptions...),}}@@ -255,7 +255,6 @@ func (s *DockerClientService) WatchEvents(ctx context.Context) {}result := dockerClient.Events(ctx, client.EventsListOptions{})- s.publishImageStateResyncInternal()streamStart := time.Now()err = s.consumeEventsInternal(ctx, result.Messages, result.Err)if err != nil && !errors.Is(err, context.Canceled) && !errors.Is(err, io.EOF) {@@ -265,7 +264,7 @@ func (s *DockerClientService) WatchEvents(ctx context.Context) {// Only a stream that actually stayed up counts as recovery. Resetting// unconditionally before Events() meant a daemon that accepts the// connection and drops it immediately was reconnected at the floor- // interval forever, purging the container update-info cache each time.+ // interval forever.if time.Since(streamStart) >= dockerEventStreamHealthyAfter {eventBackoff.Reset()}@@ -276,13 +275,6 @@ func (s *DockerClientService) WatchEvents(ctx context.Context) {}}-func (s *DockerClientService) publishImageStateResyncInternal() {- s.EventBus().Publish(events.Message{- Type: events.ImageEventType,- Action: docker.ImageStateResyncAction,- })-}-func (s *DockerClientService) consumeEventsInternal(ctx context.Context, messages <-chan events.Message, errs <-chan error) error {for {select {@@ -292,6 +284,10 @@ func (s *DockerClientService) consumeEventsInternal(ctx context.Context, messageif !ok {return nil}+ // Stamp missing daemon timestamps once, before normal and overflow delivery diverge.+ if msg.TimeNano == 0 {+ msg.TimeNano = time.Now().UnixNano()+ }s.EventBus().Publish(msg)case err, ok := <-errs:if !ok {diff --git a/backend/internal/docker/service_test.go b/backend/internal/docker/service_test.goindex 619c4a331..7abc9598d 100644--- a/backend/internal/docker/service_test.go+++ b/backend/internal/docker/service_test.go@@ -12,7 +12,6 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/actors""github.com/getarcaneapp/arcane/backend/v2/internal/config"- docker "github.com/getarcaneapp/arcane/backend/v2/pkg/dockerutil"imagetypes "github.com/getarcaneapp/arcane/types/v2/image""github.com/moby/moby/api/types/container""github.com/moby/moby/api/types/events"@@ -173,23 +172,21 @@ func TestDockerClientService_RefreshClientProbeFailureKeepsCachedClient(t *testiassert.False(t, svc.clientLastProbe.IsZero())}-func TestDockerClientService_PublishImageStateResyncNotifiesSubscribers(t *testing.T) {- ctx, cancel := context.WithCancel(context.Background())- t.Cleanup(cancel)- svc := NewDockerClientService(ctx, nil, &config.Config{}, nil)+func TestDockerClientService_PublishesDaemonImageEventsInternal(t *testing.T) {+ svc := NewDockerClientService(t.Context(), nil, &config.Config{}, nil)t.Cleanup(svc.Close)-eventCh, unsubscribe := svc.EventBus().Subscribe(events.ImageEventType)t.Cleanup(unsubscribe)-- svc.publishImageStateResyncInternal()-+ messages := make(chan events.Message, 1)+ expected := events.Message{Type: events.ImageEventType, Action: events.ActionPull, TimeNano: 123, Actor: events.Actor{ID: "nginx:latest"}}+ messages <- expected+ close(messages)+ require.NoError(t, svc.consumeEventsInternal(t.Context(), messages, nil))select {case message := <-eventCh:- require.Equal(t, events.ImageEventType, message.Type)- require.Equal(t, docker.ImageStateResyncAction, message.Action)- case <-time.After(time.Second):- require.FailNow(t, "timed out waiting for image state resync event")+ require.Equal(t, expected, message)+ default:+ t.Fatal("daemon image event was not published")}}@@ -236,9 +233,8 @@ func TestDockerClientService_EventActorStopCancelsAndJoinsStreamInternal(t *test}select {case message := <-eventsCh:- require.Equal(t, docker.ImageStateResyncAction, message.Action)- case <-time.After(time.Second):- require.FailNow(t, "Docker event stream did not publish reconnect resync")+ t.Fatalf("connecting without daemon events published an unexpected event: %v", message)+ default:}stopCtx, cancel := context.WithTimeout(context.Background(), time.Second)diff --git a/backend/internal/event/docker_correlation.go b/backend/internal/event/docker_correlation.gonew file mode 100644index 000000000..ffe2bf6f7--- /dev/null+++ b/backend/internal/event/docker_correlation.go@@ -0,0 +1,241 @@+package event++import (+ "strings"+ "sync"+ "time"+)++const (+ dockerExpectationTTL = 60 * time.Second+ dockerSuppressionWindowGrace = 10 * time.Second+)++type dockerExpectationInternal struct {+ resourceType, resourceID, resourceName string+}++type dockerWindowKeyInternal struct {+ kind, name string+ resource dockerExpectationInternal+}++type dockerWindowInternal struct {+ active int+ expires time.Time+}++type dockerCorrelationInternal struct {+ mu sync.Mutex+ expectations map[dockerExpectationInternal]time.Time+ windows map[dockerWindowKeyInternal]dockerWindowInternal+ now func() time.Time+ updatingContainers func() []string+}++func (c *dockerCorrelationInternal) timeInternal() time.Time {+ if c.now != nil {+ return c.now()+ }+ return time.Now()+}++func (c *dockerCorrelationInternal) pruneInternal(now time.Time) {+ for key, expiry := range c.expectations {+ if !now.Before(expiry) {+ delete(c.expectations, key)+ }+ }+ for key, window := range c.windows {+ if window.active == 0 && !now.Before(window.expires) {+ delete(c.windows, key)+ }+ }+}++// MarkDockerExpectation correlates subsequent daemon observations with a local Arcane action.+func (s *EventService) MarkDockerExpectation(resourceType, resourceID, resourceName string) {+ if s == nil {+ return+ }+ switch resourceType {+ case "container", "image", "volume", "network":+ default:+ return+ }+ if resourceName == "name" {+ resourceName = ""+ }+ if resourceID == "" && resourceName == "" {+ return+ }+ c := &s.dockerCorrelation+ c.mu.Lock()+ defer c.mu.Unlock()+ now := c.timeInternal()+ c.pruneInternal(now)+ if c.expectations == nil {+ c.expectations = make(map[dockerExpectationInternal]time.Time)+ }+ c.expectations[dockerExpectationInternal{resourceType, resourceID, resourceName}] = now.Add(dockerExpectationTTL)+}++// BeginComposeSuppressionWindow covers daemon events labeled with the Compose project.+// Unlabeled resources require an explicit resource expectation to avoid hiding unrelated activity.+func (s *EventService) BeginComposeSuppressionWindow(composeProject string) func() {+ if composeProject == "" {+ return func() {}+ }+ return s.beginDockerWindowsInternal([]dockerWindowKeyInternal{{kind: "compose", name: composeProject}})+}++// BeginDockerResourceSuppressionWindow covers a mutation for its full duration and cleanup grace.+func (s *EventService) BeginDockerResourceSuppressionWindow(resourceType, resourceID, resourceName string) func() {+ if resourceName == "name" {+ resourceName = ""+ }+ if resourceID == "" && resourceName == "" {+ return func() {}+ }+ return s.beginDockerWindowsInternal([]dockerWindowKeyInternal{{kind: "resource", resource: dockerExpectationInternal{resourceType, resourceID, resourceName}}})+}++func (s *EventService) beginDockerWindowsInternal(keys []dockerWindowKeyInternal) func() {+ if s == nil {+ return func() {}+ }+ c := &s.dockerCorrelation+ c.mu.Lock()+ c.pruneInternal(c.timeInternal())+ if c.windows == nil {+ c.windows = make(map[dockerWindowKeyInternal]dockerWindowInternal)+ }+ for _, key := range keys {+ window := c.windows[key]+ window.active+++ c.windows[key] = window+ }+ c.mu.Unlock()+ return sync.OnceFunc(func() {+ c.mu.Lock()+ defer c.mu.Unlock()+ for _, key := range keys {+ window := c.windows[key]+ window.active--+ window.expires = c.timeInternal().Add(dockerSuppressionWindowGrace)+ c.windows[key] = window+ }+ })+}++// SetDockerUpdatingContainers supplies the updater's live identities without coupling domains.+func (s *EventService) SetDockerUpdatingContainers(source func() []string) {+ if s == nil {+ return+ }+ s.dockerCorrelation.mu.Lock()+ defer s.dockerCorrelation.mu.Unlock()+ s.dockerCorrelation.updatingContainers = source+}++// ShouldSuppressDaemonEvent reports whether a daemon observation matches a recent local action.+func (s *EventService) ShouldSuppressDaemonEvent(resourceType, actorID, actorName, composeProject string) bool {+ if s == nil {+ return false+ }+ c := &s.dockerCorrelation+ c.mu.Lock()+ updating := c.updatingContainers+ c.mu.Unlock()+ // The updater records stop after Docker returns, so active updates also need correlation.+ if resourceType == "container" && updating != nil {+ for _, id := range updating() {+ if id != "" && (id == actorID || dockerIDMatchesInternal(resourceType, id, actorID)) {+ return true+ }+ }+ }+ c.mu.Lock()+ defer c.mu.Unlock()+ c.pruneInternal(c.timeInternal())++ for exp := range c.expectations {+ if exp.matchesInternal(resourceType, actorID, actorName) {+ return true+ }+ }+ for key := range c.windows {+ switch key.kind {+ case "resource":+ if key.resource.matchesInternal(resourceType, actorID, actorName) {+ return true+ }+ case "compose":+ if composeProject == key.name {+ return true+ }+ }+ }++ return false+}++func (exp dockerExpectationInternal) matchesInternal(resourceType, actorID, actorName string) bool {+ if exp.resourceType != resourceType {+ return false+ }+ if exp.resourceID != "" && (exp.resourceID == actorID || exp.resourceID == actorName || dockerIDMatchesInternal(resourceType, exp.resourceID, actorID)) {+ return true+ }+ return exp.resourceName != "" && (exp.resourceName == actorName || exp.resourceName == actorID)+}++func dockerIDMatchesInternal(resourceType, expected, actual string) bool {+ if resourceType == "volume" {+ return false+ }+ if resourceType == "image" {+ expected = strings.TrimPrefix(expected, "sha256:")+ actual = strings.TrimPrefix(actual, "sha256:")+ }+ if len(expected) < 12 || len(expected) > 64 || len(actual) != 64 {+ return false+ }+ for _, id := range []string{expected, actual} {+ for _, ch := range id {+ if ch < '0' || ch > '9' && ch < 'a' || ch > 'f' {+ return false+ }+ }+ }+ return strings.HasPrefix(actual, expected)+}++func (s *EventService) correlateCreatedEventInternal(req CreateEventRequest) {+ if req.ResourceType == nil || req.Metadata["source"] == "docker" {+ return+ }+ if req.EnvironmentID != nil && *req.EnvironmentID != "" && *req.EnvironmentID != "0" {+ return+ }+ // Failure and observational records do not identify a successful Docker mutation.+ //exhaustive:ignore+ switch req.Type {+ case EventTypeContainerStart, EventTypeContainerStop, EventTypeContainerRestart,+ EventTypeContainerDelete, EventTypeContainerCreate, EventTypeContainerUpdate,+ EventTypeContainerDeploy, EventTypeContainerKill, EventTypeContainerPause, EventTypeContainerUnpause,+ EventTypeImagePull, EventTypeImageLoad, EventTypeImageTag, EventTypeImageCommit, EventTypeImageDelete,+ EventTypeVolumeCreate, EventTypeVolumeDelete, EventTypeVolumeRename,+ EventTypeNetworkCreate, EventTypeNetworkDelete:+ default:+ return+ }+ var id, name string+ if req.ResourceID != nil {+ id = *req.ResourceID+ }+ if req.ResourceName != nil {+ name = *req.ResourceName+ }+ s.MarkDockerExpectation(*req.ResourceType, id, name)+}diff --git a/backend/internal/event/docker_correlation_test.go b/backend/internal/event/docker_correlation_test.gonew file mode 100644index 000000000..a79f71728--- /dev/null+++ b/backend/internal/event/docker_correlation_test.go@@ -0,0 +1,134 @@+package event++import (+ "github.com/getarcaneapp/arcane/backend/v2/internal/database"+ "github.com/stretchr/testify/require"+ "strings"+ "testing"+ "time"+)++func TestDockerExpectationIdentityAndExpiry(t *testing.T) {+ t.Parallel()+ id := strings.Repeat("abcdef12", 8)+ for _, tc := range []struct {+ name, kind, expectedID, expectedName, actorID, actorName string+ want bool+ }{+ {"exact ID", "container", id, "", id, "", true},+ {"short ID", "container", id[:12], "", id, "", true},+ {"too short ID", "container", id[:11], "", id, "", false},+ {"name", "container", "", "web", "different", "web", true},+ {"placeholder name", "container", "", "name", "different", "name", false},+ {"image digest", "image", "sha256:" + id[:12], "", "sha256:" + id, "", true},+ {"image reference prefix", "image", "registry/image", "", "registry/image:latest", "", false},+ {"volume hex prefix", "volume", id[:12], "", id, "", false},+ {"exact volume name", "volume", "data", "", "data", "", true},+ {"invalid hex", "container", strings.Repeat("z", 12), "", strings.Repeat("z", 64), "", false},+ } {+ t.Run(tc.name, func(t *testing.T) {+ svc := NewEventService(nil, nil, nil)+ now := time.Now()+ svc.dockerCorrelation.now = func() time.Time { return now }+ svc.MarkDockerExpectation(tc.kind, tc.expectedID, tc.expectedName)+ require.Equal(t, tc.want, svc.ShouldSuppressDaemonEvent(tc.kind, tc.actorID, tc.actorName, ""))+ require.False(t, svc.ShouldSuppressDaemonEvent("other", tc.actorID, tc.actorName, ""))+ now = now.Add(59 * time.Second)+ require.Equal(t, tc.want, svc.ShouldSuppressDaemonEvent(tc.kind, tc.actorID, tc.actorName, ""))+ now = now.Add(time.Second)+ require.False(t, svc.ShouldSuppressDaemonEvent(tc.kind, tc.actorID, tc.actorName, ""))+ })+ }+}++func TestDockerSuppressionWindowsOverlapAndGrace(t *testing.T) {+ t.Parallel()+ for _, compose := range []bool{false, true} {+ name := "resource"+ if compose {+ name = "compose"+ }+ t.Run(name, func(t *testing.T) {+ svc := NewEventService(nil, nil, nil)+ now := time.Now()+ svc.dockerCorrelation.now = func() time.Time { return now }+ open := func() func() {+ if compose {+ return svc.BeginComposeSuppressionWindow("demo")+ }+ return svc.BeginDockerResourceSuppressionWindow("container", "id", "web")+ }+ first := open()+ second := open()+ first()+ first()+ now = now.Add(time.Hour)+ require.True(t, svc.ShouldSuppressDaemonEvent("container", "id", "web", "demo"))+ if compose {+ require.False(t, svc.ShouldSuppressDaemonEvent("container", "id", "web", "other"))+ require.False(t, svc.ShouldSuppressDaemonEvent("container", "id", "web", ""))+ for _, kind := range []string{"image", "volume", "network"} {+ require.False(t, svc.ShouldSuppressDaemonEvent(kind, "id", "name", ""))+ require.True(t, svc.ShouldSuppressDaemonEvent(kind, "id", "name", "demo"))+ require.False(t, svc.ShouldSuppressDaemonEvent(kind, "id", "name", "other"))+ }+ }+ require.False(t, svc.ShouldSuppressDaemonEvent("container", "unrelated", "other", "other"))+ second()+ second()+ now = now.Add(9 * time.Second)+ for _, kind := range []string{"image", "volume", "network"} {+ require.False(t, svc.ShouldSuppressDaemonEvent(kind, "unrelated", "other", ""))+ }+ require.True(t, svc.ShouldSuppressDaemonEvent("container", "id", "web", "demo"))+ now = now.Add(time.Second)+ require.False(t, svc.ShouldSuppressDaemonEvent("container", "id", "web", "demo"))+ require.False(t, svc.ShouldSuppressDaemonEvent("image", "id", "name", ""))+ })+ }+}++func TestCreateEventCorrelationEligibility(t *testing.T) {+ for _, tc := range []struct {+ name string+ environment *string+ source string+ eventType EventType+ want bool+ }{+ {"local", new("0"), "", EventTypeContainerStart, true},+ {"implicit local", nil, "", EventTypeContainerStart, true},+ {"remote", new("remote"), "", EventTypeContainerStart, false},+ {"daemon", new("0"), "docker", EventTypeContainerStart, false},+ {"failure", new("0"), "", EventTypeContainerError, false},+ {"container scan", new("0"), "", EventTypeContainerScan, false},+ {"image scan", new("0"), "", EventTypeImageScan, false},+ {"volume backup", new("0"), "", EventTypeVolumeBackupCreate, false},+ } {+ t.Run(tc.name, func(t *testing.T) {+ db := setupEventServiceTestDB(t)+ svc := NewEventService(db, nil, nil)+ _, err := svc.CreateEvent(t.Context(), CreateEventRequest{Type: tc.eventType, Title: "action", ResourceType: new(strings.SplitN(string(tc.eventType), ".", 2)[0]), ResourceID: new("id"), EnvironmentID: tc.environment, Metadata: database.JSON{"source": tc.source}})+ require.NoError(t, err)+ require.Equal(t, tc.want, svc.ShouldSuppressDaemonEvent(strings.SplitN(string(tc.eventType), ".", 2)[0], "id", "", ""))+ })+ }+}++func TestDockerResourceWindowsCoverLongOperationsInternal(t *testing.T) {+ svc := NewEventService(nil, nil, nil)+ now := time.Now()+ svc.dockerCorrelation.now = func() time.Time { return now }+ closeFirst := svc.BeginDockerResourceSuppressionWindow("image", "", "nginx:latest")+ closeSecond := svc.BeginDockerResourceSuppressionWindow("image", "", "nginx:latest")+ closeFirst()+ closeFirst()+ now = now.Add(time.Hour)+ require.True(t, svc.ShouldSuppressDaemonEvent("image", "nginx:latest", "", ""))+ require.False(t, svc.ShouldSuppressDaemonEvent("image", "redis:latest", "", ""))+ closeSecond()+ now = now.Add(9 * time.Second)+ require.True(t, svc.ShouldSuppressDaemonEvent("image", "nginx:latest", "", ""))+ now = now.Add(time.Second)+ require.False(t, svc.ShouldSuppressDaemonEvent("image", "nginx:latest", "", ""))+}diff --git a/backend/internal/event/docker_events.go b/backend/internal/event/docker_events.gonew file mode 100644index 000000000..166c0b7eb--- /dev/null+++ b/backend/internal/event/docker_events.go@@ -0,0 +1,177 @@+package event++import (+ "context"+ "encoding/json/v2"+ "fmt"+ "log/slog"+ "sync"+ "time"++ "github.com/getarcaneapp/arcane/backend/v2/internal/database"+ "github.com/google/uuid"+ "github.com/moby/moby/api/types/events"+ "go.getarcane.app/streams/bus"+)++const daemonEventChanBuffer = 256++// SubscribeDockerEvents prepares subscriptions before the watcher starts. The caller+// runs the returned worker and calls cleanup after joining it, including on failed startup.+func (s *EventService) SubscribeDockerEvents(eventBus *bus.DockerEventBus) (run func(context.Context) error, cleanup func()) {+ containers, unsubscribeContainers := eventBus.Subscribe(events.ContainerEventType, bus.WithSubscriberBuffer(daemonEventChanBuffer))+ images, unsubscribeImages := eventBus.Subscribe(events.ImageEventType, bus.WithSubscriberBuffer(daemonEventChanBuffer))+ volumes, unsubscribeVolumes := eventBus.Subscribe(events.VolumeEventType, bus.WithSubscriberBuffer(daemonEventChanBuffer))+ networks, unsubscribeNetworks := eventBus.Subscribe(events.NetworkEventType, bus.WithSubscriberBuffer(daemonEventChanBuffer))+ cleanup = sync.OnceFunc(func() {+ unsubscribeContainers()+ unsubscribeImages()+ unsubscribeVolumes()+ unsubscribeNetworks()+ })+ return func(ctx context.Context) error {+ return s.runDockerEventsInternal(ctx, containers, images, volumes, networks)+ }, cleanup+}++func (s *EventService) runDockerEventsInternal(ctx context.Context, containers, images, volumes, networks <-chan events.Message) error {+ ticker := time.NewTicker(time.Minute)+ defer ticker.Stop()+ for containers != nil || images != nil || volumes != nil || networks != nil {+ var msg events.Message+ var ok bool+ select {+ case <-ctx.Done():+ return nil+ case msg, ok = <-containers:+ if !ok {+ containers = nil+ continue+ }+ case msg, ok = <-images:+ if !ok {+ images = nil+ continue+ }+ case msg, ok = <-volumes:+ if !ok {+ volumes = nil+ continue+ }+ case msg, ok = <-networks:+ if !ok {+ networks = nil+ continue+ }+ case <-ticker.C:+ s.dockerCorrelation.mu.Lock()+ s.dockerCorrelation.pruneInternal(s.dockerCorrelation.timeInternal())+ s.dockerCorrelation.mu.Unlock()+ continue+ }+ s.RecordDockerEvent(ctx, msg)+ }+ return nil+}++// RecordDockerEvent persists a daemon occurrence once across normal and overflow delivery.+func (s *EventService) RecordDockerEvent(ctx context.Context, msg events.Message) {+ if ctx.Err() != nil {+ return+ }+ req, ok := mapDaemonEventInternal(msg)+ if !ok {+ return+ }+ if s.ShouldSuppressDaemonEvent(string(msg.Type), msg.Actor.ID, *req.ResourceName, msg.Actor.Attributes["com.docker.compose.project"]) {+ return+ }+ if msg.TimeNano != 0 {+ identity, err := json.Marshal(msg, json.Deterministic(true))+ if err != nil {+ slog.WarnContext(ctx, "Failed to identify Docker daemon event", "type", req.Type, "resourceId", msg.Actor.ID, "error", err)+ return+ }+ req.deduplicationID = uuid.NewSHA1(uuid.NameSpaceOID, identity).String()+ }+ if _, err := s.CreateEvent(ctx, req); err != nil {+ slog.WarnContext(ctx, "Failed to log Docker daemon event", "type", req.Type, "resourceId", msg.Actor.ID, "error", err)+ }+}++var daemonEventTypesInternal = map[events.Type]map[events.Action]EventType{+ events.ContainerEventType: {+ events.ActionCreate: EventTypeContainerCreate,+ events.ActionStart: EventTypeContainerStart,+ events.ActionStop: EventTypeContainerStop,+ events.ActionRestart: EventTypeContainerRestart,+ events.ActionDie: EventTypeContainerDie,+ events.ActionOOM: EventTypeContainerOOM,+ events.ActionKill: EventTypeContainerKill,+ events.ActionDestroy: EventTypeContainerDelete,+ events.ActionPause: EventTypeContainerPause,+ events.ActionUnPause: EventTypeContainerUnpause,+ events.ActionRename: EventTypeContainerRename,+ events.ActionUpdate: EventTypeContainerUpdate,+ events.ActionHealthStatusUnhealthy: EventTypeContainerUnhealthy,+ },+ events.ImageEventType: {+ events.ActionPull: EventTypeImagePull,+ events.ActionDelete: EventTypeImageDelete,+ events.ActionTag: EventTypeImageTag,+ events.ActionUnTag: EventTypeImageUntag,+ events.ActionImport: EventTypeImageImport,+ events.ActionLoad: EventTypeImageLoad,+ events.ActionPrune: EventTypeImagePrune,+ },+ events.VolumeEventType: {+ events.ActionCreate: EventTypeVolumeCreate,+ events.ActionDestroy: EventTypeVolumeDelete,+ events.ActionPrune: EventTypeVolumePrune,+ },+ events.NetworkEventType: {+ events.ActionCreate: EventTypeNetworkCreate,+ events.ActionDestroy: EventTypeNetworkDelete,+ events.ActionPrune: EventTypeNetworkPrune,+ },+}++func mapDaemonEventInternal(msg events.Message) (CreateEventRequest, bool) {+ eventType := daemonEventTypesInternal[msg.Type][msg.Action]+ if eventType == "" || (msg.Actor.ID == "" && msg.Action != events.ActionPrune) {+ return CreateEventRequest{}, false+ }+ severity := EventSeverityInfo+ if eventType == EventTypeContainerDie && msg.Actor.Attributes["exitCode"] != "0" || eventType == EventTypeContainerUnhealthy {+ severity = EventSeverityWarning+ }+ if eventType == EventTypeContainerOOM {+ severity = EventSeverityError+ }++ name := msg.Actor.Attributes["name"]+ if name == "" {+ name = msg.Actor.ID+ }+ if name == "" {+ name = "prune"+ }+ metadata := database.JSON{"source": "docker", "action": string(msg.Action), "scope": msg.Scope}+ for _, key := range []string{"name", "image", "exitCode", "signal"} {+ if value, ok := msg.Actor.Attributes[key]; ok {+ metadata[key] = value+ }+ }+ for attr, key := range map[string]string{"com.docker.compose.project": "composeProject", "com.docker.compose.service": "composeService"} {+ if value, ok := msg.Actor.Attributes[attr]; ok {+ metadata[key] = value+ }+ }+ return CreateEventRequest{+ Type: eventType, Severity: severity,+ Title: fmt.Sprintf("Docker %s %s: %s", msg.Type, msg.Action, name),+ Description: fmt.Sprintf("%s '%s': %s observed from the Docker daemon", msg.Type, name, msg.Action),+ ResourceType: new(string(msg.Type)), ResourceID: new(msg.Actor.ID), ResourceName: new(name),+ EnvironmentID: new("0"), Metadata: metadata,+ }, true+}diff --git a/backend/internal/event/docker_events_test.go b/backend/internal/event/docker_events_test.gonew file mode 100644index 000000000..7982cad0a--- /dev/null+++ b/backend/internal/event/docker_events_test.go@@ -0,0 +1,225 @@+package event++import (+ "context"+ "errors"+ "sync/atomic"+ "testing"+ "testing/synctest"+ "time"++ "github.com/getarcaneapp/arcane/backend/v2/internal/database"+ "github.com/moby/moby/api/types/events"+ "github.com/stretchr/testify/require"+ "go.getarcane.app/streams/bus"+ "gorm.io/gorm"+)++func TestMapDaemonEventInternal(t *testing.T) {+ t.Parallel()+ cases := []struct {+ name string+ kind events.Type+ action events.Action+ want EventType+ }{+ {"container create", events.ContainerEventType, events.ActionCreate, EventTypeContainerCreate},+ {"container start", events.ContainerEventType, events.ActionStart, EventTypeContainerStart},+ {"container stop", events.ContainerEventType, events.ActionStop, EventTypeContainerStop},+ {"container restart", events.ContainerEventType, events.ActionRestart, EventTypeContainerRestart},+ {"container die", events.ContainerEventType, events.ActionDie, EventTypeContainerDie},+ {"container oom", events.ContainerEventType, events.ActionOOM, EventTypeContainerOOM},+ {"container kill", events.ContainerEventType, events.ActionKill, EventTypeContainerKill},+ {"container destroy", events.ContainerEventType, events.ActionDestroy, EventTypeContainerDelete},+ {"container pause", events.ContainerEventType, events.ActionPause, EventTypeContainerPause},+ {"container unpause", events.ContainerEventType, events.ActionUnPause, EventTypeContainerUnpause},+ {"container rename", events.ContainerEventType, events.ActionRename, EventTypeContainerRename},+ {"container update", events.ContainerEventType, events.ActionUpdate, EventTypeContainerUpdate},+ {"container unhealthy", events.ContainerEventType, events.ActionHealthStatusUnhealthy, EventTypeContainerUnhealthy},+ {"image pull", events.ImageEventType, events.ActionPull, EventTypeImagePull},+ {"image delete", events.ImageEventType, events.ActionDelete, EventTypeImageDelete},+ {"image tag", events.ImageEventType, events.ActionTag, EventTypeImageTag},+ {"image untag", events.ImageEventType, events.ActionUnTag, EventTypeImageUntag},+ {"image load", events.ImageEventType, events.ActionLoad, EventTypeImageLoad},+ {"image import", events.ImageEventType, events.ActionImport, EventTypeImageImport},+ {"image prune", events.ImageEventType, events.ActionPrune, EventTypeImagePrune},+ {"volume create", events.VolumeEventType, events.ActionCreate, EventTypeVolumeCreate},+ {"volume destroy", events.VolumeEventType, events.ActionDestroy, EventTypeVolumeDelete},+ {"volume prune", events.VolumeEventType, events.ActionPrune, EventTypeVolumePrune},+ {"network create", events.NetworkEventType, events.ActionCreate, EventTypeNetworkCreate},+ {"network destroy", events.NetworkEventType, events.ActionDestroy, EventTypeNetworkDelete},+ {"network prune", events.NetworkEventType, events.ActionPrune, EventTypeNetworkPrune},+ }+ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ req, ok := mapDaemonEventInternal(events.Message{Type: tc.kind, Action: tc.action, Scope: "local", Actor: events.Actor{ID: "resource-id", Attributes: map[string]string{"name": "web", "image": "alpine", "exitCode": "0", "signal": "15", "com.docker.compose.project": "demo", "com.docker.compose.service": "web", "secret": "never-copy"}}})+ require.True(t, ok)+ require.Equal(t, tc.want, req.Type)+ require.Equal(t, "web", *req.ResourceName)+ require.Equal(t, "0", *req.EnvironmentID)+ require.Nil(t, req.UserID)+ require.Nil(t, req.Username)+ require.Equal(t, database.JSON{"source": "docker", "action": string(tc.action), "scope": "local", "name": "web", "image": "alpine", "exitCode": "0", "signal": "15", "composeProject": "demo", "composeService": "web"}, req.Metadata)+ severity := EventSeverityInfo+ if tc.action == events.ActionOOM {+ severity = EventSeverityError+ }+ if tc.action == events.ActionHealthStatusUnhealthy {+ severity = EventSeverityWarning+ }+ require.Equal(t, severity, req.Severity)+ })+ }+ for _, exitCode := range []string{"1", "137", ""} {+ t.Run("die exit "+exitCode, func(t *testing.T) {+ req, ok := mapDaemonEventInternal(events.Message{Type: events.ContainerEventType, Action: events.ActionDie, Actor: events.Actor{ID: "id", Attributes: map[string]string{"exitCode": exitCode}}})+ require.True(t, ok)+ require.Equal(t, EventSeverityWarning, req.Severity)+ require.Equal(t, "id", *req.ResourceName)+ })+ }+ for _, kind := range []events.Type{events.ImageEventType, events.VolumeEventType, events.NetworkEventType} {+ t.Run(string(kind)+" empty prune", func(t *testing.T) {+ req, ok := mapDaemonEventInternal(events.Message{Type: kind, Action: events.ActionPrune})+ require.True(t, ok)+ require.Equal(t, "prune", *req.ResourceName)+ })+ }+ for _, tc := range []struct {+ name string+ kind events.Type+ action events.Action+ id string+ }{+ {"exec", events.ContainerEventType, "exec_create", "id"}, {"attach", events.ContainerEventType, "attach", "id"}, {"resize", events.ContainerEventType, "resize", "id"}, {"healthy", events.ContainerEventType, "health_status: healthy", "id"}, {"mount", events.VolumeEventType, "mount", "id"}, {"connect", events.NetworkEventType, "connect", "id"}, {"disconnect", events.NetworkEventType, "disconnect", "id"}, {"unknown action", events.ImageEventType, "unknown-image-action", "image-id"}, {"empty create", events.ContainerEventType, events.ActionCreate, ""},+ } {+ t.Run(tc.name, func(t *testing.T) {+ _, ok := mapDaemonEventInternal(events.Message{Type: tc.kind, Action: tc.action, Actor: events.Actor{ID: tc.id}})+ require.False(t, ok)+ })+ }+}++func TestDaemonEventsPersistEveryOccurrenceImmediately(t *testing.T) {+ db := setupEventServiceTestDB(t)+ svc := NewEventService(db, nil, nil)+ die := events.Message{Type: events.ContainerEventType, Action: events.ActionDie, Actor: events.Actor{ID: "web", Attributes: map[string]string{"exitCode": "0"}}}+ stop := die+ stop.Action = events.ActionStop+ for index, msg := range []events.Message{die, stop, die, stop} {+ msg.TimeNano = int64(index + 1)+ svc.RecordDockerEvent(t.Context(), msg)+ requireDaemonCountInternal(t, db, int64(index+1))+ }+ var rows []Event+ require.NoError(t, db.Find(&rows).Error)+ for _, row := range rows {+ require.Equal(t, "System", *row.Username)+ require.Equal(t, "0", *row.EnvironmentID)+ require.Equal(t, "docker", row.Metadata["source"])+ }+}++func TestDaemonSuppressionAndFailureAllowLaterObservations(t *testing.T) {+ for _, failure := range []bool{false, true} {+ name := "suppression"+ if failure {+ name = "persistence failure"+ }+ t.Run(name, func(t *testing.T) {+ db := setupEventServiceTestDB(t)+ svc := NewEventService(db, nil, nil)+ now := time.Now()+ svc.dockerCorrelation.now = func() time.Time { return now }+ msg := events.Message{Type: events.ContainerEventType, Action: events.ActionStart, TimeNano: 123, Actor: events.Actor{ID: "web"}}+ if failure {+ require.NoError(t, db.Callback().Create().Before("gorm:create").Register("daemon_failure", func(tx *gorm.DB) { tx.AddError(errors.New("unavailable")) }))+ }+ if !failure {+ svc.MarkDockerExpectation("container", "web", "")+ }+ svc.RecordDockerEvent(t.Context(), msg)+ requireDaemonCountInternal(t, db, 0)+ if failure {+ require.NoError(t, db.Callback().Create().Remove("daemon_failure"))+ }+ now = now.Add(time.Minute)+ svc.RecordDockerEvent(t.Context(), msg)+ requireDaemonCountInternal(t, db, 1)+ })+ }+}++func TestDockerEventSubscriptionsReadyAndStop(t *testing.T) {+ for _, closeBus := range []bool{false, true} {+ name := "cancellation"+ if closeBus {+ name = "closed bus"+ }+ t.Run(name, func(t *testing.T) {+ synctest.Test(t, func(t *testing.T) {+ db := setupEventServiceTestDB(t)+ sqlDB, err := db.DB.DB()+ require.NoError(t, err)+ defer sqlDB.Close()+ sqlDB.SetMaxOpenConns(1)+ svc := NewEventService(db, nil, nil)+ var recovered, published atomic.Int64+ stopChanges := svc.changes.Subscribe(func(struct{}) { published.Add(1) })+ defer stopChanges()+ eventBus := bus.NewDockerEventBus(bus.WithDroppedEventCallback(func(message events.Message) {+ recovered.Add(1)+ svc.RecordDockerEvent(t.Context(), message)+ }))+ defer eventBus.Close()+ run, cleanup := svc.SubscribeDockerEvents(eventBus)+ defer cleanup()+ // A stalled unrelated subscriber also invokes the global overflow callback.+ _, stopStalled := eventBus.Subscribe(events.ImageEventType, bus.WithSubscriberBuffer(1))+ defer stopStalled()+ const occurrences = daemonEventChanBuffer + 64+ publishBurst := func(offset int64) {+ for occurrence := range occurrences {+ for _, kind := range []events.Type{events.ContainerEventType, events.ImageEventType, events.VolumeEventType, events.NetworkEventType} {+ action := events.ActionCreate+ if kind == events.ImageEventType {+ action = events.ActionPull+ }+ eventBus.Publish(events.Message{Type: kind, Action: action, TimeNano: offset + int64(occurrence+1), Actor: events.Actor{ID: "resource"}})+ }+ }+ }+ publishBurst(0)+ require.Positive(t, recovered.Load())++ ctx, cancel := context.WithCancel(t.Context())+ defer cancel()+ done := make(chan error, 1)+ go func() { done <- run(ctx) }()+ synctest.Wait()+ requireDaemonCountInternal(t, db, 4*occurrences)+ require.Equal(t, int64(4*occurrences), published.Load())+ publishBurst(occurrences)+ synctest.Wait()+ requireDaemonCountInternal(t, db, 8*occurrences)+ require.Equal(t, int64(8*occurrences), published.Load())+ if closeBus {+ eventBus.Close()+ } else {+ cancel()+ }+ synctest.Wait()+ require.NoError(t, <-done)+ cleanup()+ cleanup()+ })+ })+ }+}++func requireDaemonCountInternal(t *testing.T, db *database.DB, want int64) {+ t.Helper()+ var count int64+ require.NoError(t, db.Model(&Event{}).Count(&count).Error)+ require.Equal(t, want, count)+}diff --git a/backend/internal/event/handler.go b/backend/internal/event/handler.goindex c2f876011..eee2f7d39 100644--- a/backend/internal/event/handler.go+++ b/backend/internal/event/handler.go@@ -2,15 +2,12 @@ package eventimport ("context"- "crypto/subtle""encoding/json/v2"- "log/slog""net/http""strings""emperror.dev/errors""github.com/danielgtaylor/huma/v2"- "github.com/getarcaneapp/arcane/backend/v2/internal/config""github.com/getarcaneapp/arcane/backend/v2/internal/middleware""github.com/getarcaneapp/arcane/backend/v2/pkg/authz""github.com/getarcaneapp/arcane/backend/v2/pkg/utils"@@ -62,8 +59,8 @@ type DeleteEventInput struct {// RegisterAgentEventIngestion registers the manager ingestion endpoint used by// direct agents when no edge tunnel is active. This route is not part of the-// Huma/OpenAPI surface and authenticates only with the configured agent token.-func RegisterAgentEventIngestion(g *echo.Group, eventService *EventService, cfg *config.Config) {+// Huma/OpenAPI surface and authenticates with the originating environment token.+func RegisterAgentEventIngestion(g *echo.Group, eventService *EventService, resolveEnvironment func(context.Context, string) (string, error)) {g.POST("/events", func(c *echo.Context) error {if eventService == nil {return c.JSON(http.StatusInternalServerError, base.ApiResponse[base.MessageResponse]{@@ -71,14 +68,15 @@ func RegisterAgentEventIngestion(g *echo.Group, eventService *EventService, cfgData: base.MessageResponse{Message: "service not available"},})}- if cfg == nil || strings.TrimSpace(cfg.AgentToken) == "" {- slog.Warn("agent event ingestion is disabled because agent token is not configured")++ if resolveEnvironment == nil {return c.JSON(http.StatusServiceUnavailable, base.ApiResponse[base.MessageResponse]{Success: false,Data: base.MessageResponse{Message: "agent event ingestion is not configured"},})}- if !validAgentEventIngestionTokenInternal(c.Request(), cfg) {+ environmentID, err := resolveEnvironment(c.Request().Context(), c.Request().Header.Get(utils.HeaderAgentToken))+ if err != nil || environmentID == "" || environmentID == "0" {return c.JSON(http.StatusUnauthorized, base.ApiResponse[base.MessageResponse]{Success: false,Data: base.MessageResponse{Message: "invalid agent token"},@@ -99,7 +97,7 @@ func RegisterAgentEventIngestion(g *echo.Group, eventService *EventService, cfg})}- if _, err := eventService.CreateEvent(c.Request().Context(), input); err != nil {+ if _, err := eventService.IngestAgentEvent(c.Request().Context(), environmentID, input); err != nil {return c.JSON(http.StatusInternalServerError, base.ApiResponse[base.MessageResponse]{Success: false,Data: base.MessageResponse{Message: errors.WithMessage(err, "Failed to create event").Error()},@@ -113,20 +111,6 @@ func RegisterAgentEventIngestion(g *echo.Group, eventService *EventService, cfg})}-func validAgentEventIngestionTokenInternal(r *http.Request, cfg *config.Config) bool {- if cfg == nil {- return false- }- token := r.Header.Get(utils.HeaderAgentToken)- if token == "" || cfg.AgentToken == "" {- return false- }- // Constant time, matching auth.AgentTokenMatches in the auth middleware:- // this endpoint is unauthenticated apart from the token, so a byte-by-byte- // comparison is directly probeable.- return subtle.ConstantTimeCompare([]byte(token), []byte(cfg.AgentToken)) == 1-}-// RegisterEvents registers all event management endpoints.func RegisterEvents(api huma.API, eventService *EventService) {h := &EventHandler{diff --git a/backend/internal/event/model.go b/backend/internal/event/model.goindex fb7c2c23f..b46f937ba 100644--- a/backend/internal/event/model.go+++ b/backend/internal/event/model.go@@ -12,6 +12,16 @@ type ()const (+ EventTypeContainerDie EventType = "container.die"+ EventTypeContainerOOM EventType = "container.oom"+ EventTypeContainerRename EventType = "container.rename"+ EventTypeContainerUnhealthy EventType = "container.unhealthy"+ EventTypeImageUntag EventType = "image.untag"+ EventTypeImageImport EventType = "image.import"+ EventTypeImagePrune EventType = "image.prune"+ EventTypeVolumePrune EventType = "volume.prune"+ EventTypeNetworkPrune EventType = "network.prune"+// EventTypeContainerStart and the constants below enumerate Arcane event types.EventTypeContainerStart EventType = "container.start"EventTypeContainerStop EventType = "container.stop"diff --git a/backend/internal/event/module.go b/backend/internal/event/module.goindex 6bb514732..80d3c80bb 100644--- a/backend/internal/event/module.go+++ b/backend/internal/event/module.go@@ -2,6 +2,7 @@package eventimport (+ "context""net/http""github.com/danielgtaylor/huma/v2"@@ -20,14 +21,12 @@ type Dependencies struct {// Module owns event persistence and both of the domain's HTTP surfaces.type Module struct {service *EventService- config *config.Config}// New builds the event domain from its dependencies.func New(deps Dependencies) *Module {return &Module{service: NewEventService(deps.DB, deps.Config, deps.HTTPClient),- config: deps.Config,}}@@ -49,10 +48,10 @@ func (m *Module) RegisterRoutes(api huma.API) {}// RegisterAgentRoutes mounts the token-authenticated direct-agent ingestion endpoint.-func (m *Module) RegisterAgentRoutes(group *echo.Group) {+func (m *Module) RegisterAgentRoutes(group *echo.Group, resolveEnvironment func(context.Context, string) (string, error)) {if m == nil {RegisterAgentEventIngestion(group, nil, nil)return}- RegisterAgentEventIngestion(group, m.service, m.config)+ RegisterAgentEventIngestion(group, m.service, resolveEnvironment)}diff --git a/backend/internal/event/service.go b/backend/internal/event/service.goindex 2a4a2de96..8e4c24132 100644--- a/backend/internal/event/service.go+++ b/backend/internal/event/service.go@@ -16,6 +16,7 @@ import ("emperror.dev/errors"+ "github.com/getarcaneapp/arcane/backend/v2/internal/actors""github.com/getarcaneapp/arcane/backend/v2/internal/config""github.com/getarcaneapp/arcane/backend/v2/internal/database""github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/edge"@@ -28,12 +29,15 @@ import ("golang.org/x/text/cases""golang.org/x/text/language""gorm.io/gorm"+ "gorm.io/gorm/clause")type EventService struct {- db *database.DB- cfg *config.Config- httpClient *http.Client+ changes *actors.Signal[struct{}]+ dockerCorrelation dockerCorrelationInternal+ db *database.DB+ cfg *config.Config+ httpClient *http.Client}func NewEventService(db *database.DB, cfg *config.Config, httpClient *http.Client) *EventService {@@ -43,24 +47,28 @@ func NewEventService(db *database.DB, cfg *config.Config, httpClient *http.Clien}}return &EventService{- db: db,- cfg: cfg,- httpClient: httpClient,+ changes: actors.NewSignal[struct{}](),+ dockerCorrelation: dockerCorrelationInternal{now: time.Now},+ db: db,+ cfg: cfg,+ httpClient: httpClient,}}type CreateEventRequest struct {- Type EventType `json:"type"`- Severity EventSeverity `json:"severity,omitempty"`- Title string `json:"title"`- Description string `json:"description,omitempty"`- ResourceType *string `json:"resourceType,omitempty"`- ResourceID *string `json:"resourceId,omitempty"`- ResourceName *string `json:"resourceName,omitempty"`- UserID *string `json:"userId,omitempty"`- Username *string `json:"username,omitempty"`- EnvironmentID *string `json:"environmentId,omitempty"`- Metadata database.JSON `json:"metadata,omitempty"`+ // Internal identity for replay-safe daemon delivery; never accepted from API payloads.+ deduplicationID string+ Type EventType `json:"type"`+ Severity EventSeverity `json:"severity,omitempty"`+ Title string `json:"title"`+ Description string `json:"description,omitempty"`+ ResourceType *string `json:"resourceType,omitempty"`+ ResourceID *string `json:"resourceId,omitempty"`+ ResourceName *string `json:"resourceName,omitempty"`+ UserID *string `json:"userId,omitempty"`+ Username *string `json:"username,omitempty"`+ EnvironmentID *string `json:"environmentId,omitempty"`+ Metadata database.JSON `json:"metadata,omitempty"`}func (s *EventService) CreateEvent(ctx context.Context, req CreateEventRequest) (*Event, error) {@@ -71,6 +79,8 @@ func (s *EventService) CreateEvent(ctx context.Context, req CreateEventRequest)userID, username := normalizeEventActor(req.UserID, req.Username)eventRecord := &Event{+ ID: req.deduplicationID,+ CreatedAt: time.Now(),Type: req.Type,Severity: severity,Title: req.Title,@@ -83,24 +93,44 @@ func (s *EventService) CreateEvent(ctx context.Context, req CreateEventRequest)EnvironmentID: req.EnvironmentID,Metadata: req.Metadata,Timestamp: time.Now(),- CreatedAt: time.Now(),}+ var inserted boolerr := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {- if err := tx.Create(eventRecord).Error; err != nil {- return errors.WrapIf(err, "failed to create event")+ if req.deduplicationID != "" {+ tx = tx.Clauses(clause.OnConflict{Columns: []clause.Column{{Name: "id"}}, DoNothing: true})+ }+ result := tx.Create(eventRecord)+ if result.Error != nil {+ return errors.WrapIf(result.Error, "failed to create event")}+ inserted = result.RowsAffected > 0return nil})if err != nil {return nil, err}+ if !inserted {+ return eventRecord, nil+ }+ s.correlateCreatedEventInternal(req)+ s.changes.Publish(struct{}{})s.forwardEventToManager(ctx, eventRecord)return eventRecord, nil}+// IngestAgentEvent assigns the authenticated environment instead of trusting the agent's local ID.+func (s *EventService) IngestAgentEvent(ctx context.Context, environmentID string, req CreateEventRequest) (*Event, error) {+ environmentID = strings.TrimSpace(environmentID)+ if environmentID == "" || environmentID == "0" {+ return nil, errors.New("remote environment is required for agent event ingestion")+ }+ req.EnvironmentID = &environmentID+ return s.CreateEvent(ctx, req)+}+func (s *EventService) forwardEventToManager(ctx context.Context, eventModel *Event) {if eventModel == nil || s.cfg == nil || !s.cfg.AgentMode {return@@ -422,7 +452,7 @@ func (s *EventService) GetEventSeverityCounts(ctx context.Context) (EventSeverit}func (s *EventService) DeleteEvent(ctx context.Context, eventID string) error {- return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {result := tx.Delete(&Event{}, "id = ?", eventID)if result.Error != nil {return errors.WrapIf(result.Error, "failed to delete event")@@ -432,17 +462,27 @@ func (s *EventService) DeleteEvent(ctx context.Context, eventID string) error {}return nil})+ if err == nil {+ s.changes.Publish(struct{}{})+ }+ return err}func (s *EventService) DeleteOldEvents(ctx context.Context, olderThan time.Duration) error {cutoff := time.Now().Add(-olderThan)- return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ var deleted int64+ err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {result := tx.Where("timestamp < ?", cutoff).Delete(&Event{})if result.Error != nil {return errors.WrapIf(result.Error, "failed to delete old events")}+ deleted = result.RowsAffectedreturn nil})+ if err == nil && deleted > 0 {+ s.changes.Publish(struct{}{})+ }+ return err}func (s *EventService) LogContainerEvent(ctx context.Context, eventType EventType, containerID, containerName, userID, username, environmentID string, metadata database.JSON) error {diff --git a/backend/internal/event/service_test.go b/backend/internal/event/service_test.goindex 83457f207..2341fee6f 100644--- a/backend/internal/event/service_test.go+++ b/backend/internal/event/service_test.go@@ -14,6 +14,7 @@ import ("github.com/getarcaneapp/arcane/backend/v2/pkg/pagination""github.com/getarcaneapp/arcane/backend/v2/pkg/utils""github.com/libtnb/sqlite"+ "github.com/moby/moby/api/types/events""github.com/stretchr/testify/assert""github.com/stretchr/testify/require""gorm.io/gorm"@@ -343,3 +344,83 @@ func TestEventService_ListEventsPaginated_TypeCategoryFilter(t *testing.T) {require.ElementsMatch(t, []string{"image.pull"}, listWithTypeFilter("image.pull"))require.ElementsMatch(t, []string{"container.start", "container.stop", "image.pull"}, listWithTypeFilter("container,image.pull"))}++func TestIngestAgentEventAuthenticatedEnvironment(t *testing.T) {+ for _, supplied := range []string{"0", "unrelated-environment", ""} {+ t.Run("payload environment "+supplied, func(t *testing.T) {+ db := setupEventServiceTestDB(t)+ svc := NewEventService(db, nil, nil)+ req, ok := mapDaemonEventInternal(events.Message{Type: events.ContainerEventType, Action: events.ActionStart, Actor: events.Actor{ID: "container-id", Attributes: map[string]string{"name": "web", "com.docker.compose.project": "demo"}}})+ require.True(t, ok)+ req.EnvironmentID = &supplied+ recorded, err := svc.IngestAgentEvent(t.Context(), " remote-environment ", req)+ require.NoError(t, err)+ require.Equal(t, "remote-environment", *recorded.EnvironmentID)+ require.Equal(t, "System", *recorded.Username)+ require.Equal(t, req.Metadata, recorded.Metadata)+ require.False(t, svc.ShouldSuppressDaemonEvent("container", "container-id", "web", "demo"))+ var persisted Event+ require.NoError(t, db.First(&persisted).Error)+ require.Equal(t, "remote-environment", *persisted.EnvironmentID)+ require.Equal(t, database.JSON{"source": "docker", "action": "start", "scope": "", "name": "web", "composeProject": "demo"}, persisted.Metadata)++ // Attributed Arcane records must not seed expectations for the manager's daemon either.+ req.Metadata = nil+ req.UserID = new("operator-id")+ req.Username = new("operator")+ recorded, err = svc.IngestAgentEvent(t.Context(), "remote-environment", req)+ require.NoError(t, err)+ require.Equal(t, "operator", *recorded.Username)+ require.False(t, svc.ShouldSuppressDaemonEvent("container", "container-id", "web", "demo"))+ })+ }+}++func TestIngestAgentEventRejectsLocalEnvironment(t *testing.T) {+ for _, environmentID := range []string{"", " ", "0", " 0 "} {+ t.Run("environment "+environmentID, func(t *testing.T) {+ db := setupEventServiceTestDB(t)+ svc := NewEventService(db, nil, nil)+ recorded, err := svc.IngestAgentEvent(t.Context(), environmentID, CreateEventRequest{Type: EventTypeContainerStart, Title: "start", EnvironmentID: new("remote-environment")})+ require.Error(t, err)+ require.Nil(t, recorded)+ requireDaemonCountInternal(t, db, 0)+ })+ }+}++func TestDaemonEventForwardingPreservesMetadata(t *testing.T) {+ requests := make(chan CreateEventRequest, 4)+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ var req CreateEventRequest+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {+ t.Errorf("decode forwarded event: %v", err)+ w.WriteHeader(http.StatusBadRequest)+ return+ }+ requests <- req+ w.WriteHeader(http.StatusAccepted)+ }))+ defer server.Close()+ db := setupEventServiceTestDB(t)+ svc := NewEventService(db, &config.Config{AgentMode: true, AgentToken: "agent-token", ManagerApiUrl: server.URL}, server.Client())+ message := events.Message{Type: events.ContainerEventType, Action: events.ActionDie, TimeNano: 123, Actor: events.Actor{ID: "container-id", Attributes: map[string]string{"name": "web", "exitCode": "137", "signal": "9"}}}+ req, ok := mapDaemonEventInternal(message)+ require.True(t, ok)+ svc.RecordDockerEvent(t.Context(), message)+ svc.RecordDockerEvent(t.Context(), message)+ select {+ case payload := <-requests:+ require.Equal(t, req.Metadata, payload.Metadata)+ require.Equal(t, EventSeverityWarning, payload.Severity)+ require.Equal(t, EventTypeContainerDie, payload.Type)+ require.Equal(t, "System", *payload.Username)+ require.Equal(t, "0", *payload.EnvironmentID)+ require.Equal(t, "container-id", *payload.ResourceID)+ case <-time.After(2 * time.Second):+ t.Fatal("timed out waiting for daemon event forwarding")+ }+ require.Never(t, func() bool { return len(requests) != 0 }, 50*time.Millisecond, time.Millisecond)+ requireDaemonCountInternal(t, db, 1)++}diff --git a/backend/internal/event/stream.go b/backend/internal/event/stream.gonew file mode 100644index 000000000..842c7e63e--- /dev/null+++ b/backend/internal/event/stream.go@@ -0,0 +1,37 @@+package event++import (+ "context"+ "time"++ eventtypes "github.com/getarcaneapp/arcane/types/v2/event"+ "go.getarcane.app/streams/agg"+)++// RunStreamProducer signals committed event changes so clients can refresh their current query.+func (s *EventService) RunStreamProducer(ctx context.Context, events chan<- eventtypes.StreamEvent) {+ changed := make(chan struct{}, 1)+ unsubscribe := s.changes.Subscribe(func(struct{}) {+ // One pending invalidation covers all changes, without blocking event persistence.+ select {+ case changed <- struct{}{}:+ default:+ }+ })+ defer unsubscribe()++ // Subscribe first so connecting and reconnecting clients cannot miss a change.+ if !agg.Send(ctx, events, eventtypes.StreamEvent{Type: "changed", Timestamp: time.Now()}) {+ return+ }+ for {+ select {+ case <-ctx.Done():+ return+ case <-changed:+ if !agg.Send(ctx, events, eventtypes.StreamEvent{Type: "changed", Timestamp: time.Now()}) {+ return+ }+ }+ }+}diff --git a/backend/internal/event/stream_test.go b/backend/internal/event/stream_test.gonew file mode 100644index 000000000..7b25d2f0b--- /dev/null+++ b/backend/internal/event/stream_test.go@@ -0,0 +1,100 @@+package event++import (+ "context"+ "testing"+ "testing/synctest"+ "time"++ eventtypes "github.com/getarcaneapp/arcane/types/v2/event"+ "github.com/stretchr/testify/require"+)++func TestEventStreamPublishesCommittedMutations(t *testing.T) {+ db := setupEventServiceTestDB(t)+ service := NewEventService(db, nil, nil)+ changes := 0+ var persistedCounts []int64+ unsubscribe := service.changes.Subscribe(func(struct{}) {+ changes+++ var count int64+ require.NoError(t, db.Model(&Event{}).Count(&count).Error)+ persistedCounts = append(persistedCounts, count)+ })+ defer unsubscribe()+ created, err := service.CreateEvent(t.Context(), CreateEventRequest{Type: EventTypeImagePull, Title: "Pulled"})+ require.NoError(t, err)+ require.Equal(t, 1, changes)+ _, err = service.IngestAgentEvent(t.Context(), "remote", CreateEventRequest{Type: EventTypeImagePull, Title: "Remote pull"})+ require.NoError(t, err)+ require.Equal(t, 2, changes)+ require.NoError(t, service.DeleteOldEvents(t.Context(), time.Hour))+ require.Equal(t, 2, changes)+ require.Error(t, service.DeleteEvent(t.Context(), "missing"))+ require.Equal(t, 2, changes)+ require.NoError(t, service.DeleteEvent(t.Context(), created.ID))+ require.Equal(t, 3, changes)+ require.NoError(t, service.DeleteOldEvents(t.Context(), -time.Hour))+ require.Equal(t, 4, changes)+ require.Equal(t, []int64{1, 2, 1, 0}, persistedCounts)+ require.NoError(t, db.Migrator().DropTable(&Event{}))+ _, err = service.CreateEvent(t.Context(), CreateEventRequest{Title: "Cannot persist"})+ require.Error(t, err)+ require.Error(t, service.DeleteOldEvents(t.Context(), time.Hour))+ require.Error(t, service.DeleteEvent(t.Context(), created.ID))+ require.Equal(t, 4, changes)+}++func TestEventStreamProducerCoalescesAndCancels(t *testing.T) {+ synctest.Test(t, func(t *testing.T) {+ service := NewEventService(nil, nil, nil)+ ctx, cancel := context.WithCancel(t.Context())+ defer cancel()+ output := make(chan eventtypes.StreamEvent)+ stopped := make(chan struct{})+ go func() {+ defer close(stopped)+ service.RunStreamProducer(ctx, output)+ }()+ synctest.Wait()+ // Initial send is blocked, but subscriptions must already be ready.+ for range 100 {+ service.changes.Publish(struct{}{})+ }+ initial := <-output+ require.Equal(t, "changed", initial.Type)+ require.False(t, initial.Timestamp.IsZero())+ require.Equal(t, "changed", (<-output).Type)+ synctest.Wait()+ select {+ case <-output:+ t.Fatal("burst should coalesce to one pending invalidation")+ default:+ }+ // A stalled client must not hold up publishers or prevent shutdown.+ service.changes.Publish(struct{}{})+ synctest.Wait()+ cancel()+ <-stopped+ service.changes.Publish(struct{}{})+ })+}++func TestEventStreamProducerBroadcasts(t *testing.T) {+ synctest.Test(t, func(t *testing.T) {+ service := NewEventService(nil, nil, nil)+ ctx, cancel := context.WithCancel(t.Context())+ defer cancel()+ first := make(chan eventtypes.StreamEvent, 1)+ second := make(chan eventtypes.StreamEvent, 1)+ go service.RunStreamProducer(ctx, first)+ go service.RunStreamProducer(ctx, second)+ synctest.Wait()+ <-first+ <-second+ service.changes.Publish(struct{}{})+ synctest.Wait()+ require.Equal(t, "changed", (<-first).Type)+ require.Equal(t, "changed", (<-second).Type)+ })+}diff --git a/backend/internal/image/image.go b/backend/internal/image/image.goindex 4e367f526..6f2c0c00a 100644--- a/backend/internal/image/image.go+++ b/backend/internal/image/image.go@@ -156,6 +156,13 @@ func (s *ImageService) RemoveImage(ctx context.Context, id string, force bool, uPruneChildren: true,}+ defer s.eventService.BeginDockerResourceSuppressionWindow("image", id, imageName)()+ if inspectErr == nil {+ defer s.eventService.BeginDockerResourceSuppressionWindow("image", imageDetails.ID, "")()+ for _, tag := range imageDetails.RepoTags {+ defer s.eventService.BeginDockerResourceSuppressionWindow("image", "", tag)()+ }+ }_, err = dockerClient.ImageRemove(ctx, id, options)if err != nil {s.eventService.LogErrorEvent(ctx, event.EventTypeImageError, "image", id, imageName, user.ID, user.Username, "0", err, database.JSON{"action": "delete", "force": force})@@ -213,6 +220,7 @@ func (s *ImageService) PullImage(ctx context.Context, imageName string, progressinitialHasAuth := pullOptions.RegistryAuth != ""retriedWithoutAuth := false+ defer s.eventService.BeginDockerResourceSuppressionWindow("image", "", imageName)()reader, err := dockerClient.ImagePull(ctx, imageName, pullOptions)if err != nil && ShouldRetryAnonymousPull(pullOptions, err) {retriedWithoutAuth = true@@ -305,6 +313,7 @@ func (s *ImageService) TagImage(ctx context.Context, source string, req imagetypreturn errors.WrapIf(err, "failed to connect to Docker")}+ defer s.eventService.BeginDockerResourceSuppressionWindow("image", "", target)()_, err = dockerClient.ImageTag(ctx, client.ImageTagOptions{Source: source, Target: target})if err != nil {s.eventService.LogErrorEvent(ctx, event.EventTypeImageError, "image", "", source, user.ID, user.Username, "0", err, database.JSON{"action": "tag", "target": target})diff --git a/backend/internal/image/service_test.go b/backend/internal/image/service_test.goindex 972124477..54788f225 100644--- a/backend/internal/image/service_test.go+++ b/backend/internal/image/service_test.go@@ -443,12 +443,15 @@ func TestGetPullOptionsWithAuth_ExternalCredentialsOverrideDBRegistryInternal(tfunc TestImageServicePullImageRetriesAnonymouslyAfterAuthRejectedInternal(t *testing.T) {db := setupImageProjectTestDBInternal(t)+ eventService := event.NewEventService(db, nil, nil)var authHeaders []stringserver := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {if !strings.HasSuffix(r.URL.Path, "/images/create") {http.NotFound(w, r)return}+ assert.True(t, eventService.ShouldSuppressDaemonEvent("image", "", "registry.example.com/team/app:latest", ""))+ assert.False(t, eventService.ShouldSuppressDaemonEvent("image", "", "registry.example.com/team/other:latest", ""))authHeaders = append(authHeaders, r.Header.Get(dockerregistry.AuthHeader))if len(authHeaders) == 1 {http.Error(w, "unauthorized", http.StatusUnauthorized)@@ -459,7 +462,7 @@ func TestImageServicePullImageRetriesAnonymouslyAfterAuthRejectedInternal(t *test.Cleanup(server.Close)dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}- imageSvc := NewImageService(db, dockerService, nil, nil, nil, event.NewEventService(db, nil, nil))+ imageSvc := NewImageService(db, dockerService, nil, nil, nil, eventService)err := imageSvc.PullImage(context.Background(), "registry.example.com/team/app:latest", io.Discard, common.SystemUser, []containerregistry.Credential{{URL: "https://registry.example.com", Username: "external-user", Token: "external-token", Enabled: true},@@ -472,19 +475,21 @@ func TestImageServicePullImageRetriesAnonymouslyAfterAuthRejectedInternal(t *tesfunc TestImageServiceTagImageCallsDockerAPIInternal(t *testing.T) {db := setupImageProjectTestDBInternal(t)+ eventService := event.NewEventService(db, nil, nil)var gotRepo, gotTag stringserver := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {if r.Method != http.MethodPost || imageDockerTestPathInternal(r.URL.Path) != "/images/source:latest/tag" {http.NotFound(w, r)return}+ assert.True(t, eventService.ShouldSuppressDaemonEvent("image", "new-image-id", "registry.example.com/team/app:v2", ""))gotRepo = r.URL.Query().Get("repo")gotTag = r.URL.Query().Get("tag")w.WriteHeader(http.StatusCreated)}))t.Cleanup(server.Close)- imageSvc := NewImageService(db, &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}, nil, nil, nil, event.NewEventService(db, nil, nil))+ imageSvc := NewImageService(db, &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}, nil, nil, nil, eventService)err := imageSvc.TagImage(context.Background(), "source:latest", imagetypes.TagRequest{Repository: "registry.example.com/team/app", Tag: "v2"}, common.SystemUser)require.NoError(t, err)diff --git a/backend/internal/network/service.go b/backend/internal/network/service.goindex 16ded8789..c4f0dbf36 100644--- a/backend/internal/network/service.go+++ b/backend/internal/network/service.go@@ -185,6 +185,7 @@ func (s *NetworkService) CreateNetwork(ctx context.Context, name string, optionsreturn nil, errors.WrapIf(err, "failed to connect to Docker")}+ defer s.eventService.BeginDockerResourceSuppressionWindow("network", "", name)()response, err := dockerClient.NetworkCreate(ctx, name, options)if err != nil {s.eventService.LogErrorEvent(ctx, event.EventTypeNetworkError, "network", "", name, user.ID, user.Username, "0", err, database.JSON{"action": "create", "driver": options.Driver})@@ -228,6 +229,7 @@ func (s *NetworkService) RemoveNetwork(ctx context.Context, id string, user commnetworkName = id}+ defer s.eventService.BeginDockerResourceSuppressionWindow("network", id, networkName)()if _, err := dockerClient.NetworkRemove(ctx, id, client.NetworkRemoveOptions{}); err != nil {s.eventService.LogErrorEvent(ctx, event.EventTypeNetworkError, "network", id, networkName, user.ID, user.Username, "0", err, database.JSON{"action": "delete"})return errors.WrapIf(err, "failed to remove network")diff --git a/backend/internal/project/project_lifecycle.go b/backend/internal/project/project_lifecycle.goindex a1558238a..0efc660aa 100644--- a/backend/internal/project/project_lifecycle.go+++ b/backend/internal/project/project_lifecycle.go@@ -87,6 +87,8 @@ func (s *ProjectService) UpdateProjectServices(ctx context.Context, projectID streturn errors.WrapIf(err, "failed to load compose project")}+ defer s.eventService.BeginComposeSuppressionWindow(compProj.Name)()+// 2. Set status to deploying/restartingif err := s.updateProjectStatusInternal(ctx, projectID, ProjectStatusDeploying); err != nil {return err@@ -215,6 +217,13 @@ func (s *ProjectService) DeployProject(ctx context.Context, projectID string, usif err := s.updateProjectStatusInternal(ctx, projectID, ProjectStatusDeploying); err != nil {return errors.WrapIf(err, "failed to update project status to deploying")}+ var closeSuppression func()+ defer func() {+ if closeSuppression != nil {+ closeSuppression()+ }+ }()+progressWriter, _ := ctx.Value(dockerutil.ProgressWriterKey{}).(io.Writer)projectModel, err := s.composeCoordinator.Deploy(ctx, projecttypes.ComposeDeployment{ProjectID: projectID, ProjectPath: projectFromDb.Path, Options: options,@@ -229,6 +238,9 @@ func (s *ProjectService) DeployProject(ctx context.Context, projectID string, us},Load: func(ctx context.Context) (*composetypes.Project, error) {model, _, err := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)+ if err == nil {+ closeSuppression = s.eventService.BeginComposeSuppressionWindow(model.Name)+ }return model, err},ResolveImages: func(ctx context.Context) (projecttypes.ComposeImageOperations, error) {@@ -270,6 +282,8 @@ func (s *ProjectService) DownProject(ctx context.Context, projectID string, userreturn errors.WrapIf(err, "failed to update project status to stopping")}+ defer s.eventService.BeginComposeSuppressionWindow(proj.Name)()+if err := projects.ComposeDown(ctx, proj, false); err != nil {_ = s.updateProjectStatusInternal(ctx, projectID, ProjectStatusRunning)return errors.WrapIf(err, "failed to bring down project")@@ -428,6 +442,7 @@ func (s *ProjectService) DestroyProject(ctx context.Context, projectID string, rif removeVolumes {if compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj); lerr == nil {+ defer s.eventService.BeginComposeSuppressionWindow(compProj.Name)()if derr := projects.ComposeDown(ctx, compProj, true); derr != nil {slog.WarnContext(ctx, "failed to remove volumes", "error", derr)}@@ -534,6 +549,8 @@ func (s *ProjectService) PullProjectImages(ctx context.Context, projectID stringreturn errors.WrapIf(lerr, "failed to load compose project")}+ defer s.eventService.BeginComposeSuppressionWindow(compProj.Name)()+for _, img := range projects.PullableImageRefs(compProj) {if err := s.pullAndReconcileImageInternal(ctx, img, progressWriter, user, credentials); err != nil {return err@@ -554,6 +571,8 @@ func (s *ProjectService) BuildProjectServices(ctx context.Context, projectID strreturn errors.WrapIff(derr, "failed to load compose project in %s", projectFromDb.Path)}+ defer s.eventService.BeginComposeSuppressionWindow(projectModel.Name)()+return s.composeCoordinator.BuildServices(ctx, projectID, projectModel, options, progressWriter, s.composeImageOperationsInternal(user, nil))}@@ -573,6 +592,8 @@ func (s *ProjectService) EnsureProjectImagesPresent(ctx context.Context, projectreturn errors.WrapIf(lerr, "failed to load compose project")}+ defer s.eventService.BeginComposeSuppressionWindow(compProj.Name)()+return s.composeCoordinator.EnsureImagesPresent(ctx, compProj, progressWriter, s.composeImageOperationsInternal(&user, credentials))}@@ -616,6 +637,8 @@ func (s *ProjectService) RestartProject(ctx context.Context, projectID string, sreturn errors.WrapIf(lerr, "failed to load compose project")}+ defer s.eventService.BeginComposeSuppressionWindow(compProj.Name)()+if err := projects.ComposeRestart(ctx, compProj, services); err != nil {_ = s.updateProjectStatusInternal(ctx, projectID, ProjectStatusRunning)return errors.WrapIf(err, "failed to restart project")diff --git a/backend/internal/project/service_test.go b/backend/internal/project/service_test.goindex 05d56b921..529f1d27e 100644--- a/backend/internal/project/service_test.go+++ b/backend/internal/project/service_test.go@@ -1113,7 +1113,8 @@ func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.TdockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)- imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, event.NewEventService(db, nil, nil))+ eventService := event.NewEventService(db, nil, nil)+ imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService)projectPath := createComposeProjectDir(t, projectsDir, "compose-update-force")require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: "+imageRef+"\n unrelated:\n image: busybox:latest\n"), 0o644))@@ -1139,6 +1140,8 @@ func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.TupCalled := falseforceRecreate := falsecomposeUpProjectServicesInternal = func(_ context.Context, selected *composetypes.Project, services []string, removeOrphans bool, force bool, _ bool, _ map[string]dockerregistry.AuthConfig, _ time.Duration) error {+ assert.True(t, eventService.ShouldSuppressDaemonEvent("container", "replacement", "app", selected.Name))+ assert.False(t, eventService.ShouldSuppressDaemonEvent("image", "pulled-image", "", ""))upCalled = trueassert.Equal(t, []string{"app"}, selected.ServiceNames())forceRecreate = force@@ -1147,9 +1150,11 @@ func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.Treturn errors.New("compose up failed after assertion")}- svc := NewProjectService(db, settingsService, nil, imageService, dockerService, nil, nil, nil, config.Load())+ svc := NewProjectService(db, settingsService, eventService, imageService, dockerService, nil, nil, nil, config.Load())err = svc.UpdateProjectServices(ctx, projectRecord.ID, []string{"app"}, common.SystemUser)require.Error(t, err)+ assert.True(t, eventService.ShouldSuppressDaemonEvent("container", "replacement", "app", "compose-update-force"), "failed updates retain correlation through rollback grace")+ assert.False(t, eventService.ShouldSuppressDaemonEvent("container", "unrelated", "unrelated", "other-project"))assert.True(t, upCalled)assert.True(t, forceRecreate, "service updates must force recreate after pulling the updated image")}diff --git a/backend/internal/updater/service.go b/backend/internal/updater/service.goindex 448b4ffb7..f8f58fa6f 100644--- a/backend/internal/updater/service.go+++ b/backend/internal/updater/service.go@@ -112,6 +112,7 @@ func NewUpdaterService(return nil, errors.WrapIf(err, "configure updater engine")}service.engine = engine+ events.SetDockerUpdatingContainers(func() []string { return engine.Status().ContainerIDs })return service, nil}diff --git a/backend/internal/updater/service_test.go b/backend/internal/updater/service_test.goindex a20862da8..720fbad47 100644--- a/backend/internal/updater/service_test.go+++ b/backend/internal/updater/service_test.go@@ -365,6 +365,17 @@ func TestUpdaterService_StatusTrackingInternal(t *testing.T) {func TestUpdaterService_DockerClientAdapterInternal(t *testing.T) {ctx := context.Background()+ t.Run("active engine updates correlate before the stop event is recorded", func(t *testing.T) {+ events := event.NewEventService(nil, nil, nil)+ svc, err := NewUpdaterService(nil, nil, nil, nil, nil, nil, events, nil, nil, nil, nil)+ require.NoError(t, err)+ end := svc.engineInternal().BeginContainerUpdate("updating-container")+ require.True(t, events.ShouldSuppressDaemonEvent("container", "updating-container", "", ""))+ require.False(t, events.ShouldSuppressDaemonEvent("container", "unrelated-container", "", ""))+ require.False(t, events.ShouldSuppressDaemonEvent("image", "updating-container", "", ""))+ end()+ require.False(t, events.ShouldSuppressDaemonEvent("container", "updating-container", "", ""))+ })t.Run("missing docker service returns unavailable error", func(t *testing.T) {svc, svcErr := NewUpdaterService(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)diff --git a/backend/internal/volume/service.go b/backend/internal/volume/service.goindex 6a85fbe08..1c8a84802 100644--- a/backend/internal/volume/service.go+++ b/backend/internal/volume/service.go@@ -161,12 +161,14 @@ func (s *VolumeService) CreateVolume(ctx context.Context, options client.VolumeCreturn nil, errors.WrapIf(err, "failed to connect to Docker")}+ defer s.eventService.BeginDockerResourceSuppressionWindow("volume", options.Name, options.Name)()created, err := dockerClient.VolumeCreate(ctx, options)if err != nil {s.eventService.LogErrorEvent(ctx, event.EventTypeVolumeError, "volume", "", options.Name, user.ID, user.Username, "0", err, database.JSON{"action": "create", "driver": options.Driver})return nil, errors.WrapIf(err, "failed to create volume")}+ defer s.eventService.BeginDockerResourceSuppressionWindow("volume", created.Volume.Name, created.Volume.Name)()vol, err := dockerClient.VolumeInspect(ctx, created.Volume.Name, client.VolumeInspectOptions{})if err != nil {s.eventService.LogErrorEvent(ctx, event.EventTypeVolumeError, "volume", created.Volume.Name, created.Volume.Name, user.ID, user.Username, "0", err, database.JSON{"action": "create", "driver": options.Driver, "step": "inspect"})@@ -201,6 +203,7 @@ func (s *VolumeService) DeleteVolume(ctx context.Context, name string, force booslog.WarnContext(ctx, "could not stop volume browse helper before delete", "volume", name, "error", stopErr.Error())}+ defer s.eventService.BeginDockerResourceSuppressionWindow("volume", name, name)()if _, err := dockerClient.VolumeRemove(ctx, name, client.VolumeRemoveOptions{Force: force,}); err != nil {diff --git a/backend/pkg/dockerutil/image_events.go b/backend/pkg/dockerutil/image_events.godeleted file mode 100644index 397b7a113..000000000--- a/backend/pkg/dockerutil/image_events.go+++ /dev/null@@ -1,6 +0,0 @@-package docker--import "github.com/moby/moby/api/types/events"--// ImageStateResyncAction identifies Arcane's synthetic image event emitted when Docker reconnects.-const ImageStateResyncAction events.Action = "arcane-resync"diff --git a/backend/pkg/scheduler/image_update_watcher.go b/backend/pkg/scheduler/image_update_watcher.goindex 2542c0a5c..0cf1ee514 100644--- a/backend/pkg/scheduler/image_update_watcher.go+++ b/backend/pkg/scheduler/image_update_watcher.go@@ -18,7 +18,6 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/common""github.com/getarcaneapp/arcane/backend/v2/internal/config""github.com/getarcaneapp/arcane/backend/v2/internal/settings"- dockerutil "github.com/getarcaneapp/arcane/backend/v2/pkg/dockerutil""github.com/getarcaneapp/arcane/types/v2/containerregistry"imageupdatetypes "github.com/getarcaneapp/arcane/types/v2/imageupdate""github.com/moby/moby/api/types/events"@@ -193,13 +192,13 @@ func (w *ImageUpdateWatcher) Start(ctx context.Context) error {return nil}return errors.New("image update watcher actor stopped unexpectedly")- case message, ok := <-eventCh:+ case _, ok := <-eventCh:if !ok {slog.WarnContext(ctx, "docker image event subscription closed; scheduled image polling remains active")eventCh = nilcontinue}- if message.Action == dockerutil.ImageStateResyncAction || !w.settingsService.GetBoolSetting(ctx, "imageEventWatcherEnabled", false) {+ if !w.settingsService.GetBoolSetting(ctx, "imageEventWatcherEnabled", false) {continue}w.Trigger()diff --git a/backend/pkg/scheduler/image_update_watcher_test.go b/backend/pkg/scheduler/image_update_watcher_test.goindex df6c1d7e4..9dcaa7a9e 100644--- a/backend/pkg/scheduler/image_update_watcher_test.go+++ b/backend/pkg/scheduler/image_update_watcher_test.go@@ -7,12 +7,12 @@ import ("log/slog""sync""testing"+ "testing/synctest""time""emperror.dev/errors""github.com/getarcaneapp/arcane/backend/v2/internal/actors""github.com/getarcaneapp/arcane/backend/v2/internal/common"- docker "github.com/getarcaneapp/arcane/backend/v2/pkg/dockerutil""github.com/getarcaneapp/arcane/types/v2/containerregistry""github.com/getarcaneapp/arcane/types/v2/imageupdate""github.com/moby/moby/api/types/events"@@ -272,32 +272,26 @@ func TestImageUpdateWatcher_EventTriggersAreOptIn(t *testing.T) {require.Never(t, func() bool { return scanner.countInternal() > 1 }, 50*time.Millisecond, 5*time.Millisecond)}-func TestImageUpdateWatcher_ImageStateResyncDoesNotTriggerScan(t *testing.T) {- scanner := &imageUpdateScannerFakeInternal{}- settings := &pollingSettingReaderFakeInternal{enabled: true, eventWatcherEnabled: true}- eventBus := bus.NewDockerEventBus()- watcher := newImageUpdateWatcherForTestInternal(t, scanner, settings, eventBus, nil)- startImageUpdateWatcherForTestInternal(t, watcher)-- require.Eventually(t, func() bool { return scanner.countInternal() == 1 }, time.Second, 5*time.Millisecond)- eventBus.Publish(events.Message{Type: events.ImageEventType, Action: docker.ImageStateResyncAction})- require.Never(t, func() bool { return scanner.countInternal() > 1 }, 50*time.Millisecond, 5*time.Millisecond)-}-func TestImageUpdateWatcher_TrailingEdgeDebounceExtendsWithNewTriggers(t *testing.T) {- scanner := &imageUpdateScannerFakeInternal{}- settings := &pollingSettingReaderFakeInternal{enabled: true}- watcher := newImageUpdateWatcherForTestInternal(t, scanner, settings, bus.NewDockerEventBus(), nil)- watcher.debounce = 50 * time.Millisecond- startImageUpdateWatcherForTestInternal(t, watcher)-- require.Eventually(t, func() bool { return scanner.countInternal() == 1 }, time.Second, time.Millisecond)- watcher.Trigger()- time.Sleep(30 * time.Millisecond)- watcher.Trigger()- time.Sleep(30 * time.Millisecond)- require.Equal(t, 1, scanner.countInternal())- require.Eventually(t, func() bool { return scanner.countInternal() == 2 }, time.Second, time.Millisecond)+ synctest.Test(t, func(t *testing.T) {+ scanner := &imageUpdateScannerFakeInternal{}+ settings := &pollingSettingReaderFakeInternal{enabled: true}+ watcher := newImageUpdateWatcherForTestInternal(t, scanner, settings, bus.NewDockerEventBus(), nil)+ watcher.debounce = 50 * time.Millisecond+ startImageUpdateWatcherForTestInternal(t, watcher)++ require.Eventually(t, func() bool { return scanner.countInternal() == 1 }, time.Second, time.Millisecond)+ watcher.Trigger()+ synctest.Wait()+ time.Sleep(30 * time.Millisecond)+ synctest.Wait()+ watcher.Trigger()+ synctest.Wait()+ time.Sleep(30 * time.Millisecond)+ synctest.Wait()+ require.Equal(t, 1, scanner.countInternal())+ require.Eventually(t, func() bool { return scanner.countInternal() == 2 }, time.Second, time.Millisecond)+ })}func TestImageUpdateWatcher_EventDuringScanQueuesOneSerializedFollowUp(t *testing.T) {@@ -396,7 +390,10 @@ func TestImageUpdateWatcher_RunNowReturnsContainedScanPanicInternal(t *testing.Tsettings := &pollingSettingReaderFakeInternal{enabled: true}watcher := newImageUpdateWatcherForTestInternal(t, scanner, settings, bus.NewDockerEventBus(), nil)startImageUpdateWatcherForTestInternal(t, watcher)- require.Eventually(t, func() bool { return scanner.countInternal() == 1 }, time.Second, time.Millisecond)+ // Wait for the actor to release startup admission, not just for the scanner to start.+ require.Eventually(t, func() bool {+ return scanner.countInternal() == 1 && !watcher.triggerIngress.Pending()+ }, time.Second, time.Millisecond)ctx, cancel := context.WithTimeout(context.Background(), time.Second)defer cancel()diff --git a/cli/go.mod b/cli/go.modindex b8d020744..20530533f 100644--- a/cli/go.mod+++ b/cli/go.mod@@ -82,6 +82,7 @@ require (github.com/subosito/gotenv v1.6.0 // indirectgithub.com/xhit/go-str2duration/v2 v2.1.0 // indirectgithub.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect+ go.getarcane.app/builds v0.4.1 // indirectgo.opentelemetry.io/auto/sdk v1.2.1 // indirectgo.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.71.0 // indirectgo.opentelemetry.io/otel v1.46.0 // indirectdiff --git a/cli/go.sum b/cli/go.sumindex 5e6353ba2..f7007d951 100644--- a/cli/go.sum+++ b/cli/go.sum@@ -168,6 +168,8 @@ github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMgithub.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=go.getarcane.app/acfs v0.6.0 h1:OOoDXmfByGWh9uJcDwtoQdWz1u2huIBhljn4mm1Ifco=go.getarcane.app/acfs v0.6.0/go.mod h1:Z+0Gs4LGNjvGMLq+TKv/oGKh29FRbAH6mcVPwY5KhFI=+go.getarcane.app/builds v0.4.1 h1:R8iEgTf9+NDtI1IEzF2R3Mn+v6AGUqwCMs7CEFpVRZk=+go.getarcane.app/builds v0.4.1/go.mod h1:vSWYulIelS9m91mPpvaN+orZ4/A20eGGcynP892eMkg=go.getarcane.app/sys/bytes v0.2.1 h1:Mm/VV1FAde3bVvzmSBxB7HVGkj7ZUw2Gbl1DPcUhlEo=go.getarcane.app/sys/bytes v0.2.1/go.mod h1:fcMYM7dknLk+KDXYAg6XOfRF22POYxcTnQeypFEjDbE=go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=diff --git a/frontend/messages/en.json b/frontend/messages/en.jsonindex 0de6d744d..41785eea4 100644--- a/frontend/messages/en.json+++ b/frontend/messages/en.json@@ -1442,12 +1442,21 @@"events_total": "Total Events","info": "Info","warning": "Warning",+ "events_col_event": "Event","events_col_severity": "Severity","resource": "Resource","events_col_time": "Time","events_category_webhook": "Webhook","events_category_notification": "Notification","events_action_restart": "Restarted",+ "events_action_kill": "Kill signal sent",+ "events_action_unpause": "Unpaused",+ "events_action_oom": "Out of memory",+ "events_action_rename": "Renamed",+ "events_action_unhealthy": "Unhealthy",+ "events_action_tag": "Tagged",+ "events_action_load": "Loaded",+ "events_action_import": "Imported","events_action_delete": "Deleted","events_action_deploy": "Deployed","events_action_pull": "Pulled",diff --git a/frontend/src/lib/components/activity/activity-center.svelte b/frontend/src/lib/components/activity/activity-center.svelteindex 8ba8b5ee2..6ffb55b8e 100644--- a/frontend/src/lib/components/activity/activity-center.svelte+++ b/frontend/src/lib/components/activity/activity-center.svelte@@ -74,32 +74,34 @@{@const cancelable = activity.status === 'running' || activity.status === 'queued'}<div class="group/activity relative"><Collapsible.Root open={expanded} onOpenChange={(open) => activityStore.setActivityExpanded(activity.id, open)}>- <Collapsible.Trigger- class="block w-full cursor-pointer appearance-none border-0 bg-transparent p-0 text-left focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-hidden focus-visible:ring-inset"- aria-label={m.activity_center_title()}- >- <ActivityListItem {activity} {expanded} {child} />- </Collapsible.Trigger>+ <div class="relative">+ <Collapsible.Trigger+ class="block w-full cursor-pointer appearance-none border-0 bg-transparent p-0 text-left focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-hidden focus-visible:ring-inset"+ aria-label={m.activity_center_title()}+ >+ <ActivityListItem {activity} {expanded} {child} />+ </Collapsible.Trigger>+ {#if cancelable}+ <IfPermitted perm="activities:cancel">+ <button+ type="button"+ onclick={() => confirmCancelActivity(activity.id)}+ disabled={activityStore.isCancelling(activity.id)}+ title={m.activity_cancel()}+ aria-label={m.activity_cancel()}+ class="absolute top-1/2 right-11 z-[var(--arcane-z-raised)] flex size-7 -translate-y-1/2 items-center justify-center rounded-md bg-background/70 text-muted-foreground opacity-0 backdrop-blur-sm transition-[opacity,color,background-color] group-hover/activity:opacity-100 hover:bg-destructive/10 hover:text-destructive focus-visible:opacity-100 focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-hidden disabled:pointer-events-none disabled:opacity-40"+ >+ <CloseIcon class="size-4" aria-hidden="true" />+ </button>+ </IfPermitted>+ {/if}+ </div><Collapsible.Contentclass="overflow-hidden data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-1 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:slide-in-from-top-1"><ActivityDetailPanel {activity} /></Collapsible.Content></Collapsible.Root>- {#if cancelable}- <IfPermitted perm="activities:cancel">- <button- type="button"- onclick={() => confirmCancelActivity(activity.id)}- disabled={activityStore.isCancelling(activity.id)}- title={m.activity_cancel()}- aria-label={m.activity_cancel()}- class="absolute top-1/2 right-11 z-[var(--arcane-z-raised)] flex size-7 -translate-y-1/2 items-center justify-center rounded-md bg-background/70 text-muted-foreground opacity-0 backdrop-blur-sm transition-[opacity,color,background-color] group-hover/activity:opacity-100 hover:bg-destructive/10 hover:text-destructive focus-visible:opacity-100 focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-hidden disabled:pointer-events-none disabled:opacity-40"- >- <CloseIcon class="size-4" aria-hidden="true" />- </button>- </IfPermitted>- {/if}</div>{/snippet}diff --git a/frontend/src/lib/components/activity/activity-detail-panel.svelte b/frontend/src/lib/components/activity/activity-detail-panel.svelteindex db6e6c246..476f7538c 100644--- a/frontend/src/lib/components/activity/activity-detail-panel.svelte+++ b/frontend/src/lib/components/activity/activity-detail-panel.svelte@@ -1,16 +1,10 @@<script lang="ts">- import { Badge } from '#lib/components/ui/badge';import { CopyButton } from '#lib/components/ui/copy-button';import { activityStore } from '#lib/stores/activity.store.svelte';import type { Activity } from '#lib/types/activity.type';- import { ActivityIcon, CloseIcon, TerminalIcon } from '#lib/icons';+ import { ActivityIcon, TerminalIcon } from '#lib/icons';import { m } from '#lib/paraglide/messages';- import IfPermitted from '#lib/components/if-permitted.svelte';import ActivityOutput from './activity-output.svelte';- import { confirmCancelActivity } from './activity-cancel';- import { activityStatusLabel, activityStatusVariant, activityTypeIcon, activityTypeLabel } from './activity-labels';- import { formatDateTime, parseInstant } from '#lib/utils/formatting';- import { Temporal } from 'temporal-polyfill';let { activity }: { activity: Activity } = $props();@@ -19,156 +13,51 @@const detail = $derived(activityStore.getDetail(activity.id));const messages = $derived(detail?.messages ?? []);const outputText = $derived(messages.map((message) => message.message).join('\n'));- const IconComponent = $derived(activityTypeIcon(liveActivity.type));const isLoading = $derived(activityStore.isDetailLoading(activity.id));const isDetailError = $derived(activityStore.isDetailError(activity.id));- const activityTarget = $derived(- liveActivity.resourceName || liveActivity.resourceId || liveActivity.resourceType || m.activity_unknown_target()- );- const sourceEnvironmentName = $derived(- liveActivity.sourceEnvironmentName || liveActivity.sourceEnvironmentId || liveActivity.environmentId- );- const startedByName = $derived(liveActivity.startedBy?.displayName || liveActivity.startedBy?.username);- const cancelable = $derived(liveActivity.status === 'running' || liveActivity.status === 'queued');-- function formatDateTimeInternal(value?: string): string {- if (!value) {- return m.common_na();- }- return formatDateTime(value, {- dateStyle: 'month-day',- includeSeconds: true- });- }-- function formatDurationInternal(value: Activity | null): string {- const startedAt = parseInstant(value?.startedAt);- const durationMs = value?.durationMs ?? (startedAt ? startedAt.until(Temporal.Now.instant()).total('milliseconds') : 0);- if (!durationMs || Number.isNaN(durationMs)) {- return m.common_na();- }- if (durationMs < 1000) {- return m.activity_duration_ms({ ms: Math.max(0, Math.round(durationMs)) });- }-- const totalSeconds = Math.round(durationMs / 1000);- if (totalSeconds < 60) {- return m.activity_duration_seconds({ seconds: totalSeconds });- }-- const minutes = Math.floor(totalSeconds / 60);- const seconds = totalSeconds % 60;- return m.activity_duration_minutes({ minutes, seconds });- }</script>-<div class="border-b border-border/50 bg-muted/25 px-4 py-3">- <div class="overflow-hidden rounded-lg border border-border/60 bg-background shadow-sm">- <div class="space-y-4 px-5 py-4">- <div class="flex min-w-0 items-start justify-between gap-4">- <div class="flex min-w-0 items-start gap-3">- <div class="flex size-9 shrink-0 items-center justify-center rounded-md bg-primary/10 text-primary">- <IconComponent class="size-4.5" aria-hidden="true" />- </div>- <div class="min-w-0">- <div class="flex flex-wrap items-center gap-2">- <h3 class="truncate text-sm font-semibold">{activityTypeLabel(liveActivity.type)}</h3>- <Badge variant={activityStatusVariant(liveActivity.status)} size="sm"- >{activityStatusLabel(liveActivity.status)}</Badge- >- </div>- <p class="mt-1 truncate text-xs text-muted-foreground">{activityTarget}</p>- </div>- </div>- {#if cancelable}- <IfPermitted perm="activities:cancel">- <button- type="button"- onclick={() => confirmCancelActivity(liveActivity.id)}- disabled={activityStore.isCancelling(liveActivity.id)}- class="inline-flex shrink-0 items-center gap-1.5 rounded-md border border-border/60 px-2.5 py-1.5 text-xs font-medium text-muted-foreground transition-colors hover:border-destructive/30 hover:bg-destructive/10 hover:text-destructive focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-hidden disabled:pointer-events-none disabled:opacity-50"- >- <CloseIcon class="size-3.5" aria-hidden="true" />- {m.activity_cancel()}- </button>- </IfPermitted>- {/if}+<div class="border-b border-border/50 bg-muted/25">+ {#if liveActivity.error}+ <div class="border-b border-destructive/30 bg-destructive/10 px-4 py-3 text-sm text-destructive">+ {liveActivity.error}+ </div>+ {/if}+ <div>+ <div class="flex items-center justify-between px-4 py-2.5">+ <div class="flex items-center gap-2">+ <TerminalIcon class="size-4 text-muted-foreground" aria-hidden="true" />+ <span class="text-sm font-semibold">{m.activity_output_title()}</span></div>+ <CopyButton text={outputText} variant="ghost" size="default" class="h-8 px-2 text-xs" tabindex={0}>+ <span class="text-xs">{m.activity_copy_output()}</span>+ </CopyButton>+ </div>- <div class="flex flex-wrap items-center gap-x-4 gap-y-1.5 text-xs text-muted-foreground">- <div class="flex items-center gap-1.5">- <span>{m.common_started()}</span>- <span class="font-medium text-foreground tabular-nums">{formatDateTimeInternal(liveActivity.startedAt)}</span>- </div>- <span class="text-border">•</span>- <div class="flex items-center gap-1.5">- <span>{m.common_finished()}</span>- <span class="font-medium text-foreground tabular-nums">{formatDateTimeInternal(liveActivity.endedAt)}</span>+ <div class="bg-zinc-950 font-mono text-[12px] leading-relaxed text-zinc-100">+ {#if isDetailError && messages.length === 0}+ <div class="flex min-h-32 flex-col items-center justify-center gap-2 text-zinc-500">+ <span>{m.activity_output_load_failed()}</span>+ <button+ type="button"+ onclick={() => activityStore.retryLoadDetail(activity.id)}+ class="text-xs text-primary underline hover:text-primary/80"+ >+ {m.common_retry()}+ </button></div>- <span class="text-border">•</span>- <div class="flex items-center gap-1.5">- <span>{m.duration()}</span>- <span class="font-medium text-foreground tabular-nums">{formatDurationInternal(liveActivity)}</span>+ {:else if isLoading && messages.length === 0}+ <div class="flex min-h-32 items-center justify-center text-zinc-500">+ <ActivityIcon class="mr-2 size-4 animate-pulse" aria-hidden="true" />+ {m.activity_output_loading()}</div>- {#if sourceEnvironmentName}- <span class="text-border">•</span>- <div class="flex items-center gap-1.5">- <span>{m.activity_source_environment()}</span>- <span class="font-medium text-foreground">{sourceEnvironmentName}</span>- </div>- {/if}- {#if startedByName}- <span class="text-border">•</span>- <div class="flex items-center gap-1.5">- <span>{m.activity_started_by_label()}</span>- <span class="font-medium text-foreground">{startedByName}</span>- </div>- {/if}- </div>-- {#if liveActivity.error}- <div class="rounded-md border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">- {liveActivity.error}+ {:else if messages.length === 0}+ <div class="flex min-h-32 items-center justify-center text-center text-zinc-500">+ {m.activity_output_empty()}</div>+ {:else}+ <ActivityOutput {messages} />{/if}</div>-- <div class="border-t border-border/60">- <div class="flex items-center justify-between px-5 py-2.5">- <div class="flex items-center gap-2">- <TerminalIcon class="size-4 text-muted-foreground" aria-hidden="true" />- <span class="text-sm font-semibold">{m.activity_output_title()}</span>- </div>- <CopyButton text={outputText} variant="ghost" size="default" class="h-8 px-2 text-xs" tabindex={0}>- <span class="text-xs">{m.activity_copy_output()}</span>- </CopyButton>- </div>-- <div class="bg-zinc-950 font-mono text-[12px] leading-relaxed text-zinc-100">- {#if isDetailError && messages.length === 0}- <div class="flex min-h-32 flex-col items-center justify-center gap-2 text-zinc-500">- <span>{m.activity_output_load_failed()}</span>- <button- type="button"- onclick={() => activityStore.retryLoadDetail(activity.id)}- class="text-xs text-primary underline hover:text-primary/80"- >- {m.common_retry()}- </button>- </div>- {:else if isLoading && messages.length === 0}- <div class="flex min-h-32 items-center justify-center text-zinc-500">- <ActivityIcon class="mr-2 size-4 animate-pulse" aria-hidden="true" />- {m.activity_output_loading()}- </div>- {:else if messages.length === 0}- <div class="flex min-h-32 items-center justify-center text-center text-zinc-500">- {m.activity_output_empty()}- </div>- {:else}- <ActivityOutput {messages} />- {/if}- </div>- </div></div></div>diff --git a/frontend/src/lib/components/activity/activity-list-item.svelte b/frontend/src/lib/components/activity/activity-list-item.svelteindex d9140eeb4..dba0f5ad0 100644--- a/frontend/src/lib/components/activity/activity-list-item.svelte+++ b/frontend/src/lib/components/activity/activity-list-item.svelte@@ -1,10 +1,11 @@<script lang="ts">+ import { Temporal } from 'temporal-polyfill';import { Progress } from '#lib/components/ui/progress/index.js';import { Badge } from '#lib/components/ui/badge';import { ArrowDownIcon } from '#lib/icons';import { m } from '#lib/paraglide/messages';import { cn } from '#lib/utils';- import { formatRelativeTime } from '#lib/utils/formatting';+ import { formatRelativeTime, formatDateTime, parseInstant } from '#lib/utils/formatting';import type { Activity, ActivityStatus } from '#lib/types/activity.type';import { activityStatusLabel, activityStatusVariant, activityTypeIcon, activityTypeLabel } from './activity-labels';@@ -21,9 +22,7 @@const IconComponent = $derived(activityTypeIcon(activity.type));const isActive = $derived(activity.status === 'running' || activity.status === 'queued');- // Resource-less activities (e.g. prunes) promote the type label instead.const resourceLabel = $derived(activity.resourceName || activity.resourceId || '');- const targetName = $derived(resourceLabel || activityTypeLabel(activity.type));const subtitle = $derived(activity.latestMessage || m.activity_no_message());const sourceEnvironmentName = $derived(activity.sourceEnvironmentName || activity.sourceEnvironmentId || activity.environmentId@@ -47,6 +46,35 @@return 'bg-muted-foreground/40';}}+ function formatDateTimeInternal(value?: string): string {+ if (!value) {+ return m.common_na();+ }+ return formatDateTime(value, {+ dateStyle: 'month-day',+ includeSeconds: true+ });+ }++ function formatDurationInternal(value: Activity | null): string {+ const startedAt = parseInstant(value?.startedAt);+ const durationMs = value?.durationMs ?? (startedAt ? startedAt.until(Temporal.Now.instant()).total('milliseconds') : 0);+ if (!durationMs || Number.isNaN(durationMs)) {+ return m.common_na();+ }+ if (durationMs < 1000) {+ return m.activity_duration_ms({ ms: Math.max(0, Math.round(durationMs)) });+ }++ const totalSeconds = Math.round(durationMs / 1000);+ if (totalSeconds < 60) {+ return m.activity_duration_seconds({ seconds: totalSeconds });+ }++ const minutes = Math.floor(totalSeconds / 60);+ const seconds = totalSeconds % 60;+ return m.activity_duration_minutes({ minutes, seconds });+ }</script><div@@ -75,19 +103,19 @@><IconComponent class={cn(child ? 'size-3.5' : 'size-4')} aria-hidden="true" /></div>- <div class="min-w-0 space-y-1.5">+ <div class={cn('flex min-w-0 flex-col gap-1.5', isActive && 'pr-8')}><div class="flex min-w-0 items-start justify-between gap-3"><div class="min-w-0 flex-1"><div class="flex min-w-0 items-center gap-2">- <span class="truncate text-sm font-semibold text-foreground">{targetName}</span>+ <span class="truncate text-sm font-semibold text-foreground">{activityTypeLabel(activity.type)}</span>{#if relativeTime}<span class="shrink-0 text-[11px] text-muted-foreground/70">· {relativeTime}</span>{/if}</div>{#if resourceLabel}- <div class="truncate text-xs text-muted-foreground">{activityTypeLabel(activity.type)}</div>+ <div class="truncate text-xs text-muted-foreground">{resourceLabel}</div>{/if}- {#if !child}+ {#if !child || expanded}<div class="flex min-w-0 flex-wrap items-center gap-x-1.5 gap-y-0.5 text-[11px] text-muted-foreground/80">{#if sourceEnvironmentName}<span class="truncate">{sourceEnvironmentName}</span>@@ -102,12 +130,28 @@<Badge variant={activityStatusVariant(activity.status)} size="sm">{activityStatusLabel(activity.status)}</Badge></div>- <div class="space-y-1.5">- <div class="line-clamp-2 text-xs leading-relaxed text-muted-foreground">{subtitle}</div>- {#if isActive && !expanded}- <Progress value={100} indeterminate class="h-1.5 rounded-full" />- {/if}- </div>+ {#if expanded}+ <div class="flex flex-wrap gap-x-4 gap-y-1 text-[11px] text-muted-foreground">+ <span+ >{m.common_started()}+ <span class="text-foreground tabular-nums">{formatDateTimeInternal(activity.startedAt)}</span></span+ >+ <span+ >{m.common_finished()}+ <span class="text-foreground tabular-nums">{formatDateTimeInternal(activity.endedAt)}</span></span+ >+ <span>{m.duration()} <span class="text-foreground tabular-nums">{formatDurationInternal(activity)}</span></span>+ </div>+ {/if}++ {#if !expanded}+ <div class="flex flex-col gap-1.5">+ <div class="line-clamp-2 text-xs leading-relaxed text-muted-foreground">{subtitle}</div>+ {#if isActive}+ <Progress value={100} indeterminate class="h-1.5 rounded-full" />+ {/if}+ </div>+ {/if}</div><div class="mt-1 flex size-6 shrink-0 items-center justify-center text-muted-foreground">diff --git a/frontend/src/lib/components/arcane-table/arcane-table-desktop-view.svelte b/frontend/src/lib/components/arcane-table/arcane-table-desktop-view.svelteindex 5218b16d9..52bba5740 100644--- a/frontend/src/lib/components/arcane-table/arcane-table-desktop-view.svelte+++ b/frontend/src/lib/components/arcane-table/arcane-table-desktop-view.svelte@@ -204,7 +204,7 @@'bg-background','group-hover/row:bg-[color-mix(in_oklab,var(--color-primary)_6%,var(--color-background))]','group-data-[state=selected]/row:bg-[color-mix(in_oklab,var(--color-primary)_12%,var(--color-background))]',- 'group-data-[expanded]/row:bg-[color-mix(in_oklab,var(--color-primary)_15%,var(--color-background))]'+ 'group-data-[expanded]/row:bg-[color-mix(in_oklab,var(--color-muted)_30%,var(--color-background))]'));@@ -254,7 +254,7 @@data-state={selectedIdSet.has(rowId) && 'selected'}data-expanded={isExpanded ? true : undefined}onclick={(event) => handleRowClick(event, rowId)}- class={cn('isolate', hasExpand && 'cursor-pointer', isExpanded && 'bg-primary/15')}+ class={cn('isolate', hasExpand && 'cursor-pointer', isExpanded && 'bg-muted/30')}>{#if hasExpand}<Table.Cell class="w-8 px-2" data-row-select-ignore>@@ -283,7 +283,7 @@</Table.Row>{#if hasExpand && isExpanded && expandedRowContent}- <Table.Row class="bg-primary/10 hover:bg-primary/10">+ <Table.Row class="bg-muted/10 hover:bg-muted/10"><Table.Cell colspan={columnsCount} class="p-0"><div transition:slide={{ duration: 200 }}><div class="px-6 py-4">diff --git a/frontend/src/lib/components/events/event-detail-panel.svelte b/frontend/src/lib/components/events/event-detail-panel.svelteindex bcae005eb..6db83d927 100644--- a/frontend/src/lib/components/events/event-detail-panel.svelte+++ b/frontend/src/lib/components/events/event-detail-panel.svelte@@ -3,10 +3,6 @@import { ArcaneButton } from '#lib/components/arcane-button/index.js';import type { Event } from '#lib/types/shared';import { m } from '#lib/paraglide/messages';- import { environmentStore, LOCAL_DOCKER_ENVIRONMENT_ID } from '#lib/stores/environment.store.svelte';- import { AlertIcon, InfoIcon } from '#lib/icons';- import { formatDateTime } from '#lib/utils/formatting';- import { eventSeverityIconVariant } from './events-labels';import { flattenMetadata, stringifyForDisplay } from './event-metadata';let { event }: { event: Event } = $props();@@ -16,19 +12,6 @@const eventJson = $derived(JSON.stringify(event, null, 2));const metadataEntries = $derived(flattenMetadata(event.metadata ?? {}));const hasMetadata = $derived(metadataEntries.length > 0);- const environmentName = $derived.by(() => {- if (!event.environmentId) {- return null;- }- const matchedEnvironment = environmentStore.available.find((env) => env.id === event.environmentId);- if (matchedEnvironment) {- return matchedEnvironment.name;- }- if (event.environmentId === LOCAL_DOCKER_ENVIRONMENT_ID) {- return m.local();- }- return event.environmentId;- });const eventErrorMessage = $derived.by(() => {const metadataError = event.metadata?.['error'];if (typeof metadataError === 'string' && metadataError.trim() !== '') {@@ -42,67 +25,10 @@}return null;});-- const severityIconClasses: Record<ReturnType<typeof eventSeverityIconVariant>, string> = {- emerald: 'bg-emerald-500/10 text-emerald-600 dark:text-emerald-400',- amber: 'bg-amber-500/10 text-amber-600 dark:text-amber-400',- red: 'bg-red-500/10 text-red-600 dark:text-red-400',- blue: 'bg-blue-500/10 text-blue-600 dark:text-blue-400'- };- const severityIconClass = $derived(severityIconClasses[eventSeverityIconVariant(event.severity)]);</script>-<div class="overflow-hidden rounded-lg border border-border/60 bg-background shadow-sm">- <div class="space-y-4 px-5 py-4">- <div class="flex min-w-0 items-start justify-between gap-4">- <div class="flex min-w-0 items-start gap-3">- <div class={['flex size-9 shrink-0 items-center justify-center rounded-md', severityIconClass]}>- {#if event.severity === 'info'}- <InfoIcon class="size-4.5" aria-hidden="true" />- {:else}- <AlertIcon class="size-4.5" aria-hidden="true" />- {/if}- </div>- <div class="min-w-0">- <h3 class="truncate text-sm font-semibold" title={event.title}>{event.title}</h3>- {#if event.description}- <p class="mt-0.5 text-sm text-muted-foreground">{event.description}</p>- {/if}- </div>- </div>- <CopyButton- text={eventJson}- variant="ghost"- size="default"- class="h-8 shrink-0 px-2 text-xs"- title={m.events_copy_full_event_json_title()}- >- <span class="text-xs">{m.common_copy_json()}</span>- </CopyButton>- </div>-- <div class="flex flex-wrap items-center gap-x-4 gap-y-1.5 text-xs text-muted-foreground">- <span class="font-medium text-foreground tabular-nums">{formatDateTime(event.timestamp, { includeSeconds: true })}</span>- {#if environmentName}- <span class="text-border">•</span>- <div class="flex items-center gap-1.5">- <span>{m.resource_environment_cap()}</span>- <span class="font-medium text-foreground">{environmentName}</span>- </div>- {/if}- <span class="text-border">•</span>- <div class="flex items-center gap-1.5">- <span>{m.common_user()}</span>- {#if (event.username ?? 'System') === 'System'}- <span class="italic">System</span>- {:else}- <span class="font-medium text-foreground">{event.username}</span>- {/if}- </div>- <span class="text-border">•</span>- <span class="font-mono">{event.type}</span>- </div>-+<div class="flex min-w-0 flex-col gap-4">+ <div class="flex flex-col gap-4">{#if eventErrorMessage}<div class="rounded-md border border-destructive/30 bg-destructive/10 p-3 text-sm break-words text-destructive">{eventErrorMessage}@@ -121,16 +47,27 @@{/if}</div>- <div class="border-t border-border/60">- <div class="flex items-center justify-between px-5 py-2.5">+ <div class="min-w-0 border-t border-border/60">+ <div class="flex flex-wrap items-center justify-between gap-2 py-2.5"><span class="text-sm font-semibold">{m.events_metadata_title()}</span>- <ArcaneButton- action="base"- tone="ghost"- size="sm"- customLabel={`${showRawEvent ? m.common_hide() : m.common_show()} ${m.common_raw()}`}- onclick={() => (showRawEvent = !showRawEvent)}- />+ <div class="flex items-center gap-2">+ <CopyButton+ text={eventJson}+ variant="ghost"+ size="default"+ class="h-8 px-2 text-xs"+ title={m.events_copy_full_event_json_title()}+ >+ <span class="text-xs">{m.common_copy_json()}</span>+ </CopyButton>+ <ArcaneButton+ action="base"+ tone="ghost"+ size="sm"+ customLabel={`${showRawEvent ? m.common_hide() : m.common_show()} ${m.common_raw()}`}+ onclick={() => (showRawEvent = !showRawEvent)}+ />+ </div></div>{#if showRawEvent}<pre class="max-h-80 overflow-auto border-t border-border/50 bg-muted/40 p-4 text-xs leading-relaxed"><code@@ -139,20 +76,22 @@{:else if hasMetadata}<div class="max-h-80 overflow-auto border-t border-border/50">{#each metadataEntries as entry (entry.key)}- <div class="grid grid-cols-[minmax(0,260px)_1fr] items-start gap-3 border-b border-border/50 px-5 py-2 last:border-b-0">+ <div+ class="grid grid-cols-[minmax(0,1fr)_minmax(0,2fr)] items-start gap-3 border-b border-border/50 py-2 last:border-b-0 sm:grid-cols-[minmax(0,260px)_minmax(0,1fr)]"+ ><div class="font-mono text-xs break-all text-muted-foreground">{entry.key}</div><pre class="font-mono text-xs leading-relaxed break-all whitespace-pre-wrap">{entry.value}</pre></div>{/each}</div>{:else}- <div class="border-t border-border/50 px-5 py-3 text-xs text-muted-foreground">{m.events_no_metadata_provided()}</div>+ <div class="border-t border-border/50 py-3 text-xs text-muted-foreground">{m.events_no_metadata_provided()}</div>{/if}</div></div>{#snippet resourceCell(label: string, value: string, copyTitle: string)}- <div class="rounded-md border border-border/50 p-3">+ <div class="min-w-0"><div class="text-xs text-muted-foreground">{label}</div><div class="mt-1 flex items-center justify-between gap-2"><div class="min-w-0 font-mono text-sm break-all">{value}</div>diff --git a/frontend/src/lib/components/events/events-labels.ts b/frontend/src/lib/components/events/events-labels.tsindex 17d73fb4d..291894a09 100644--- a/frontend/src/lib/components/events/events-labels.ts+++ b/frontend/src/lib/components/events/events-labels.ts@@ -106,11 +106,22 @@ const actionLabels: Record<string, () => string> = {start: m.common_started,stop: m.common_stopped,restart: m.events_action_restart,+ kill: m.events_action_kill,+ pause: m.paused,+ unpause: m.events_action_unpause,+ die: m.containers_status_exited,+ oom: m.events_action_oom,+ rename: m.events_action_rename,+ unhealthy: m.events_action_unhealthy,create: m.common_created,delete: m.events_action_delete,update: m.common_updated,deploy: m.events_action_deploy,pull: m.events_action_pull,+ tag: m.events_action_tag,+ untag: m.images_untagged,+ load: m.events_action_load,+ import: m.events_action_import,scan: m.events_action_scan,error: m.common_error,login: m.events_action_login,diff --git a/frontend/src/lib/services/stream-service.ts b/frontend/src/lib/services/stream-service.tsindex b7ac721a0..2ca1308a2 100644--- a/frontend/src/lib/services/stream-service.ts+++ b/frontend/src/lib/services/stream-service.ts@@ -5,6 +5,7 @@ import { streamCacheBuster } from '#lib/utils/streaming';export const STREAM_CHANNEL_ENVIRONMENTS = 'environments';export const STREAM_CHANNEL_DASHBOARD = 'dashboard';export const STREAM_CHANNEL_ACTIVITIES = 'activities';+export const STREAM_CHANNEL_EVENTS = 'events';class StreamService extends BaseAPIService {getClientStreamUrl(channels: string[], params: Record<string, string> = {}): string {diff --git a/frontend/src/lib/stores/client-stream.svelte.ts b/frontend/src/lib/stores/client-stream.svelte.tsindex de9d48e72..ce958887e 100644--- a/frontend/src/lib/stores/client-stream.svelte.ts+++ b/frontend/src/lib/stores/client-stream.svelte.ts@@ -7,6 +7,7 @@ type StreamEnvelope = {dashboard?: unknown;activity?: unknown;environment?: unknown;+ eventLog?: unknown;};type ChannelSubscriber = {@@ -47,7 +48,7 @@ function createClientStreamInternal() {}},onEvent: (envelope) => {- const payload = envelope.dashboard ?? envelope.activity ?? envelope.environment;+ const payload = envelope.dashboard ?? envelope.activity ?? envelope.environment ?? envelope.eventLog;if (!envelope.channel || payload === undefined) {return;}diff --git a/frontend/src/routes/(app)/events/+page.svelte b/frontend/src/routes/(app)/events/+page.svelteindex 7fcd1cc65..fb9b1fb9c 100644--- a/frontend/src/routes/(app)/events/+page.svelte+++ b/frontend/src/routes/(app)/events/+page.svelte@@ -8,6 +8,9 @@import { AlertIcon, CheckIcon, CloseIcon, EventsIcon, InfoIcon } from '#lib/icons';import { hasPermission } from '#lib/utils/auth';import { bulkConfirmAndRun } from '#lib/utils/bulk-actions';+ import { onMount } from 'svelte';+ import { clientStream } from '#lib/stores/client-stream.svelte';+ import { STREAM_CHANNEL_EVENTS } from '#lib/services/stream-service';let { data } = $props();@@ -42,6 +45,45 @@await Promise.all([eventsQuery.refetch(), statsQuery.refetch()]);}+ onMount(() => {+ let disposed = false;+ let refreshing = false;+ let refreshPending = false;++ async function refreshFromStream() {+ if (disposed) return;+ refreshPending = true;+ if (refreshing) return;+ refreshing = true;+ let alreadyFetching = eventsQuery.isFetching || statsQuery.isFetching;+ try {+ while (refreshPending && !disposed) {+ refreshPending = false;+ // An existing request may predate the notification; follow it with a fresh request.+ await Promise.all([eventsQuery.refetch({ cancelRefetch: false }), statsQuery.refetch({ cancelRefetch: false })]);+ refreshPending ||= alreadyFetching;+ alreadyFetching = false;+ }+ } finally {+ refreshing = false;+ }+ }++ const unsubscribe = clientStream.subscribe(STREAM_CHANNEL_EVENTS, {+ onConnected: () => void refreshFromStream(),+ onEvent: (event) => {+ if (typeof event === 'object' && event !== null && 'type' in event && event.type === 'changed') {+ void refreshFromStream();+ }+ }+ });++ return () => {+ disposed = true;+ unsubscribe();+ };+ });+const activeSeverities = $derived.by(() => {const value = requestOptions.filters?.['severity'];if (Array.isArray(value)) {diff --git a/frontend/src/routes/(app)/events/event-table.svelte b/frontend/src/routes/(app)/events/event-table.svelteindex cdfb898a1..7bda4eed5 100644--- a/frontend/src/routes/(app)/events/event-table.svelte+++ b/frontend/src/routes/(app)/events/event-table.svelte@@ -79,6 +79,11 @@}const columns = [+ {+ accessorKey: 'title',+ title: m.events_col_event(),+ cell: SummaryCell+ },{accessorKey: 'severity',title: m.events_col_severity(),@@ -128,6 +133,15 @@let mobileFieldVisibility = $state<Record<string, boolean>>({});</script>+{#snippet SummaryCell({ item }: { item: Event })}+ <div class="max-w-xl min-w-48 py-1 whitespace-normal">+ <p class="text-sm font-semibold break-words">{item.title}</p>+ {#if item.description}+ <p class="mt-0.5 line-clamp-2 text-xs text-muted-foreground" title={item.description}>{item.description}</p>+ {/if}+ </div>+{/snippet}+{#snippet SeverityCell({ value }: { value: unknown })}{@const severity = String(value ?? 'info')}<Badge variant={eventSeverityVariant(severity)} minWidth="20">{eventSeverityLabel(severity)}</Badge>@@ -229,7 +243,11 @@}]}rowActions={RowActions}- />+ >+ {#if item.description}+ <p class="text-xs leading-relaxed break-words text-muted-foreground">{item.description}</p>+ {/if}+ </UniversalMobileCard>{/snippet}{#snippet RowActions({ item }: { item: Event })}diff --git a/tests/spec/activity-center.spec.ts b/tests/spec/activity-center.spec.tsindex 294a1be4e..a438e0b0c 100644--- a/tests/spec/activity-center.spec.ts+++ b/tests/spec/activity-center.spec.ts@@ -618,36 +618,55 @@ test.describe('Activity Center', () => {const networkName = `e2e-activity-network-${Date.now()}`;let networkId: string | undefined;+ await preserveLocalEnvironmentSelection(page);+try {const created = await createNetworkViaUI(page, networkName);networkId = created.networkId;expect(created.activityId).toBeTruthy();+ const [environmentResponse, userResponse] = await Promise.all([+ page.request.get('/api/environments/0'),+ page.request.get('/api/auth/me')+ ]);+ expect(environmentResponse.ok()).toBeTruthy();+ expect(userResponse.ok()).toBeTruthy();+ const { data: environment }: { data: { name: string } } = await environmentResponse.json();+ const { data: currentUser }: { data: { username: string; displayName?: string } } =+ await userResponse.json();+ const startedBy = currentUser.displayName?.trim() || currentUser.username;+ expect(environment.name).toBeTruthy();+ expect(startedBy).toBeTruthy();+const activityCenter = await openActivityCenter(page);await expect(activityCenter.getByPlaceholder('Search activity…')).toBeVisible();await expect(activityCenter.getByRole('button', { name: 'Filter' })).toBeVisible();await expect(activityCenter.getByText('History', { exact: true })).toBeVisible();- const activityItem = activityCenter- .locator('button[aria-label="Activity Center"]')- .filter({ hasText: networkName })- .first();+ const activityItem = activityRow(activityCenter, networkName);await expect(activityItem).toBeVisible();await expect(activityItem).toContainText('Resource Action');await expect(activityItem).toContainText('Success');- await expect(activityItem).toContainText('Local');- await expect(activityItem).toContainText('Started by');+ await expect(activityItem.getByText(environment.name, { exact: true })).toBeVisible();+ await expect(+ activityItem.getByText(`Started by ${startedBy}`, { exact: true })+ ).toBeVisible();await activityItem.click();- // Collapsed rows keep their (hidden) detail panels mounted, so scope- // the assertions to the expanded panel.- const detailPanel = activityCenter.locator('[data-collapsible-content][data-state="open"]');+ await expect(activityItem).toHaveAttribute('aria-expanded', 'true');+ // Attribution stays in the row header when its output is expanded.+ await expect(activityItem.getByText(environment.name, { exact: true })).toBeVisible();+ await expect(+ activityItem.getByText(`Started by ${startedBy}`, { exact: true })+ ).toBeVisible();+ const detailPanelId = await activityItem.getAttribute('aria-controls');+ expect(detailPanelId).toBeTruthy();+ const detailPanel = activityCenter.locator(`[id=${JSON.stringify(detailPanelId)}]`);+ await expect(detailPanel).toHaveAttribute('data-state', 'open');await expect(detailPanel.getByText('Output', { exact: true })).toBeVisible();// The output pane shows the activity's messages verbatim; step labels// (e.g. "Creating network") are no longer rendered in the detail panel.await expect(detailPanel.getByText('Network created successfully').first()).toBeVisible();- await expect(detailPanel.getByText('Source environment')).toBeVisible();- await expect(detailPanel.getByText('Started by', { exact: true })).toBeVisible();} finally {await removeNetworkViaApi(page, networkId);}diff --git a/types/event/stream.go b/types/event/stream.gonew file mode 100644index 000000000..6b0174ae7--- /dev/null+++ b/types/event/stream.go@@ -0,0 +1,11 @@+package event++import "time"++// StreamEvent invalidates event queries after persistence changes.+type StreamEvent struct {+ // Type is "changed"; clients reload their current event query.+ Type string `json:"type"`+ // Timestamp is when the invalidation was emitted.+ Timestamp time.Time `json:"timestamp"`+}diff --git a/types/stream/stream.go b/types/stream/stream.goindex 86c271931..13b2c704d 100644--- a/types/stream/stream.go+++ b/types/stream/stream.go@@ -13,6 +13,7 @@ import (activitytypes "github.com/getarcaneapp/arcane/types/v2/activity"dashboardtypes "github.com/getarcaneapp/arcane/types/v2/dashboard"environmenttypes "github.com/getarcaneapp/arcane/types/v2/environment"+ eventtypes "github.com/getarcaneapp/arcane/types/v2/event")// Channel names a subscribable feed. Callers request channels explicitly@@ -22,6 +23,7 @@ const (ChannelEnvironments = "environments"ChannelDashboard = "dashboard"ChannelActivities = "activities"+ ChannelEvents = "events")// Event is one line of the multiplexed stream. Exactly one payload is set, and@@ -54,6 +56,11 @@ type Event struct {// Required: falseEnvironment *environmenttypes.StreamEvent `json:"environment,omitempty"`+ // EventLog carries a ChannelEvents invalidation.+ //+ // Required: false+ EventLog *eventtypes.StreamEvent `json:"eventLog,omitempty"`+// Timestamp is when the envelope was produced.//// Required: true