Skip to content

Modern Docker Management, Designed for Everyone

feat: stream docker daemon events to arcanes event log (#3862)

Kyle Mendell2a61718a3af9
diff --git a/backend/api/api.go b/backend/api/api.go
index 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 hand
deps.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.go
index 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.EventService
dashboard *dashboard.DashboardHandler
activity *activity.ActivityHandler
environment *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] = true
diff --git a/backend/go.sum b/backend/go.sum
index 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.go
index 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.go
index 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, docker
pullOptions = 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(c
originalConfig.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(c
return 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(c
func (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 error
if _, 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.Conte
slog.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, docker
newConfig.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, docker
return "", 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 *containe
pullCtx, 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 *containe
return 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.go
index 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.go
index d0d3d4644..0ca0e721f 100644
--- a/backend/internal/di/di_test.go
+++ b/backend/internal/di/di_test.go
@@ -2,8 +2,18 @@ package di
import (
"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.go
index 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, runtime
return 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 = cleanup
var 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.go
index 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, message
if !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.go
index 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 *testi
assert.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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index c2f876011..eee2f7d39 100644
--- a/backend/internal/event/handler.go
+++ b/backend/internal/event/handler.go
@@ -2,15 +2,12 @@ package event
import (
"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, cfg
Data: 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.go
index 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.go
index 6bb514732..80d3c80bb 100644
--- a/backend/internal/event/module.go
+++ b/backend/internal/event/module.go
@@ -2,6 +2,7 @@
package event
import (
+ "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.go
index 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 bool
err := 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 > 0
return 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.RowsAffected
return 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.go
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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, u
PruneChildren: 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, progress
initialHasAuth := 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 imagetyp
return 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.go
index 972124477..54788f225 100644
--- a/backend/internal/image/service_test.go
+++ b/backend/internal/image/service_test.go
@@ -443,12 +443,15 @@ func TestGetPullOptionsWithAuth_ExternalCredentialsOverrideDBRegistryInternal(t
func TestImageServicePullImageRetriesAnonymouslyAfterAuthRejectedInternal(t *testing.T) {
db := setupImageProjectTestDBInternal(t)
+ eventService := event.NewEventService(db, nil, nil)
var authHeaders []string
server := 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 *tes
t.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 *tes
func TestImageServiceTagImageCallsDockerAPIInternal(t *testing.T) {
db := setupImageProjectTestDBInternal(t)
+ eventService := event.NewEventService(db, nil, nil)
var gotRepo, gotTag string
server := 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.go
index 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, options
return 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 comm
networkName = 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.go
index 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 st
return errors.WrapIf(err, "failed to load compose project")
}
+ defer s.eventService.BeginComposeSuppressionWindow(compProj.Name)()
+
// 2. Set status to deploying/restarting
if err := s.updateProjectStatusInternal(ctx, projectID, ProjectStatusDeploying); err != nil {
return err
@@ -215,6 +217,13 @@ func (s *ProjectService) DeployProject(ctx context.Context, projectID string, us
if 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, user
return 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, r
if 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 string
return 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 str
return 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, project
return 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, s
return 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.go
index 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.T
dockerService := &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.T
upCalled := false
forceRecreate := false
composeUpProjectServicesInternal = 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 = true
assert.Equal(t, []string{"app"}, selected.ServiceNames())
forceRecreate = force
@@ -1147,9 +1150,11 @@ func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.T
return 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.go
index 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.go
index 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.go
index 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.VolumeC
return 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 boo
slog.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.go
deleted file mode 100644
index 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.go
index 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 = nil
continue
}
- 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.go
index 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.T
settings := &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.mod
index b8d020744..20530533f 100644
--- a/cli/go.mod
+++ b/cli/go.mod
@@ -82,6 +82,7 @@ require (
github.com/subosito/gotenv v1.6.0 // indirect
github.com/xhit/go-str2duration/v2 v2.1.0 // indirect
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
+ go.getarcane.app/builds v0.4.1 // indirect
go.opentelemetry.io/auto/sdk v1.2.1 // indirect
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.71.0 // indirect
go.opentelemetry.io/otel v1.46.0 // indirect
diff --git a/cli/go.sum b/cli/go.sum
index 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:JVG44RsyaB9T2KIHavM
github.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.json
index 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.svelte
index 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.Content
class="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.svelte
index 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.svelte
index 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.svelte
index 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.svelte
index 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.ts
index 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.ts
index 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.ts
index 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.svelte
index 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.svelte
index 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.ts
index 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.go
new file mode 100644
index 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.go
index 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: false
Environment *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