Skip to content

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

add trace local db

Justin D'Souza929eda6ee092
diff --git a/cli/beacon/cmd/endpoint.go b/cli/beacon/cmd/endpoint.go
index 3f4e39fe..6f0761af 100644
--- a/cli/beacon/cmd/endpoint.go
+++ b/cli/beacon/cmd/endpoint.go
@@ -366,6 +366,7 @@ func init() {
endpointCmd.AddCommand(endpointRepairCmd)
endpointCmd.AddCommand(endpointDashboardCmd)
endpointCmd.AddCommand(endpointOnboardingCmd)
+ endpointCmd.AddCommand(endpointTracesCmd)
for _, c := range buildDestinationCommands() {
endpointCmd.AddCommand(c)
}
@@ -386,6 +387,11 @@ func init() {
endpointHooksCmd.AddCommand(endpointHooksStatusCmd)
endpointHooksCmd.AddCommand(endpointHooksRepairInstalledCmd)
endpointUserConfigCmd.AddCommand(endpointUserConfigRepairInstalledCmd)
+ endpointTracesCmd.AddCommand(endpointTracesStatusCmd)
+ endpointTracesCmd.AddCommand(endpointTracesReindexCmd)
+ endpointTracesCmd.AddCommand(endpointTracesListCmd)
+ endpointTracesCmd.AddCommand(endpointTracesSearchCmd)
+ endpointTracesCmd.AddCommand(endpointTracesShowCmd)
endpointCoworkCmd.AddCommand(endpointCoworkPrintConfigCmd)
endpointCoworkCmd.AddCommand(endpointCoworkSetupCmd)
endpointCoworkCmd.AddCommand(endpointCoworkStatusCmd)
@@ -398,7 +404,7 @@ func init() {
endpointVSCodeCmd.AddCommand(endpointVSCodeStatusCmd)
endpointVSCodeCmd.AddCommand(endpointVSCodeValidateCmd)
- for _, c := range []*cobra.Command{endpointInstallCmd, endpointStatusCmd, endpointDoctorCmd, endpointInventoryCmd, endpointInventoryHeartbeatCmd, endpointInventoryInstallDaemonCmd, endpointDiscoverCmd, endpointTestEventCmd, endpointBundleDiagnosticsCmd, endpointUninstallCmd, endpointRepairCmd, endpointConfigShowCmd, endpointConfigValidateCmd, endpointIntegrationsValidateCmd, endpointUserConfigRepairInstalledCmd, topLevelDoctorCmd, topLevelStatusCmd, topLevelInventoryCmd} {
+ for _, c := range []*cobra.Command{endpointInstallCmd, endpointStatusCmd, endpointDoctorCmd, endpointInventoryCmd, endpointInventoryHeartbeatCmd, endpointInventoryInstallDaemonCmd, endpointDiscoverCmd, endpointTestEventCmd, endpointBundleDiagnosticsCmd, endpointUninstallCmd, endpointRepairCmd, endpointConfigShowCmd, endpointConfigValidateCmd, endpointIntegrationsValidateCmd, endpointUserConfigRepairInstalledCmd, endpointTracesStatusCmd, endpointTracesReindexCmd, endpointTracesListCmd, endpointTracesSearchCmd, endpointTracesShowCmd, topLevelDoctorCmd, topLevelStatusCmd, topLevelInventoryCmd} {
c.Flags().BoolVar(&endpointOpts.userMode, "user", true, "Use per-user endpoint paths")
c.Flags().BoolVar(&endpointOpts.systemMode, "system", false, "Use system endpoint paths and the system collector service")
c.Flags().StringVar(&endpointOpts.logPath, "log-path", "", "Runtime JSONL log path")
@@ -444,6 +450,23 @@ func init() {
endpointDashboardCmd.Flags().StringVar(&endpointOpts.dashboardAddr, "addr", dashboard.DefaultAddr, "Local dashboard listen address")
endpointDashboardCmd.Flags().BoolVar(&endpointOpts.dashboardOpen, "open", false, "Open the dashboard in a browser")
+ for _, c := range []*cobra.Command{endpointTracesStatusCmd, endpointTracesReindexCmd, endpointTracesListCmd, endpointTracesSearchCmd, endpointTracesShowCmd} {
+ c.Flags().BoolVar(&endpointOpts.jsonOutput, "json", false, "Print machine-readable JSON")
+ }
+ for _, c := range []*cobra.Command{endpointTracesListCmd, endpointTracesSearchCmd, endpointTracesShowCmd} {
+ c.Flags().IntVar(&endpointTraceOpts.limit, "limit", 100, "Limit returned traces or events")
+ c.Flags().StringVar(&endpointTraceOpts.eventTypes, "event-type", "", "Filter trace events by comma-separated type")
+ }
+ endpointTracesListCmd.Flags().StringVarP(&endpointTraceOpts.query, "query", "q", "", "Filter traces by text")
+ endpointTracesListCmd.Flags().IntVar(&endpointTraceOpts.page, "page", 1, "Page number for trace listing")
+ endpointTracesListCmd.Flags().StringVar(&endpointTraceOpts.state, "state", "", "Filter by sharing state")
+ endpointTracesListCmd.Flags().StringVar(&endpointTraceOpts.visibility, "visibility", "", "Filter by sharing visibility")
+ endpointTracesSearchCmd.Flags().StringVar(&endpointTraceOpts.resultLevel, "result-level", "trace", "Return trace or event results")
+ endpointTracesShowCmd.Flags().IntVar(&endpointTraceOpts.offset, "offset", 1, "Start at this event number")
+ endpointTracesShowCmd.Flags().IntVar(&endpointTraceOpts.aroundEvent, "around-event", 0, "Center output on this event number")
+ endpointTracesShowCmd.Flags().IntVar(&endpointTraceOpts.before, "before", 3, "Events before --around-event")
+ endpointTracesShowCmd.Flags().IntVar(&endpointTraceOpts.after, "after", 3, "Events after --around-event")
+
endpointDiscoverCmd.Flags().BoolVar(&endpointOpts.jsonOutput, "json", false, "Print discovery as JSON")
endpointDiscoverCmd.Flags().BoolVar(&endpointOpts.allTargets, "all", false, "Discover all supported runtime targets")
endpointStatusCmd.Flags().BoolVar(&endpointOpts.jsonOutput, "json", false, "Print status as JSON")
diff --git a/cli/beacon/cmd/endpoint_traces.go b/cli/beacon/cmd/endpoint_traces.go
new file mode 100644
index 00000000..6fce53d5
--- /dev/null
+++ b/cli/beacon/cmd/endpoint_traces.go
@@ -0,0 +1,198 @@
+package cmd
+
+import (
+ "encoding/json"
+ "fmt"
+ "os"
+ "strings"
+
+ "github.com/spf13/cobra"
+
+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/dashboard"
+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/lifecycle"
+)
+
+var endpointTraceOpts struct {
+ query string
+ limit int
+ page int
+ state string
+ visibility string
+ resultLevel string
+ offset int
+ aroundEvent int
+ before int
+ after int
+ eventTypes string
+}
+
+var endpointTracesCmd = &cobra.Command{
+ Use: "traces",
+ Short: "Index and search local endpoint traces",
+}
+
+var endpointTracesStatusCmd = &cobra.Command{
+ Use: "status",
+ Short: "Show local trace store status",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ logPath := endpointTraceLogPath()
+ status, err := dashboard.TraceStoreStatus(logPath)
+ if err != nil {
+ return err
+ }
+ if endpointOpts.jsonOutput {
+ return json.NewEncoder(os.Stdout).Encode(status)
+ }
+ fmt.Printf("Trace store: %s\n", status.Path)
+ fmt.Printf("Runtime log: %s\n", logPath)
+ fmt.Printf("Traces: %d\nEvents: %d\nIndex rows: %d\n", status.Traces, status.Events, status.IndexRows)
+ if status.IndexedAt != "" {
+ fmt.Printf("Indexed at: %s\n", status.IndexedAt)
+ }
+ return nil
+ },
+}
+
+var endpointTracesReindexCmd = &cobra.Command{
+ Use: "reindex",
+ Short: "Rebuild the local trace store from runtime JSONL",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ logPath := endpointTraceLogPath()
+ if err := dashboard.ReindexTraceStore(logPath); err != nil {
+ return err
+ }
+ status, err := dashboard.TraceStoreStatus(logPath)
+ if err != nil {
+ return err
+ }
+ if endpointOpts.jsonOutput {
+ return json.NewEncoder(os.Stdout).Encode(status)
+ }
+ fmt.Printf("Reindexed %d traces and %d events into %s\n", status.Traces, status.Events, status.Path)
+ return nil
+ },
+}
+
+var endpointTracesListCmd = &cobra.Command{
+ Use: "list",
+ Short: "List local traces",
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ result, err := dashboard.ReadTraceList(endpointTraceLogPath(), endpointTraceQuery())
+ if err != nil {
+ return err
+ }
+ if endpointOpts.jsonOutput {
+ return json.NewEncoder(os.Stdout).Encode(result)
+ }
+ for _, trace := range result.Traces {
+ fmt.Printf("%s\t%s\t%s\t%s\n", trace.ID, trace.Harness.Name, trace.UpdatedAt, trace.Title)
+ }
+ if result.Truncated {
+ fmt.Printf("Showing %d of %d traces; use --page or --limit to continue.\n", result.Returned, result.TotalMatched)
+ }
+ return nil
+ },
+}
+
+var endpointTracesSearchCmd = &cobra.Command{
+ Use: "search <pattern>",
+ Short: "Search local trace metadata and indexed event text",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ query := endpointTraceQuery()
+ query.Q = args[0]
+ query.ResultLevel = endpointTraceOpts.resultLevel
+ result, err := dashboard.SearchTraces(endpointTraceLogPath(), query)
+ if err != nil {
+ return err
+ }
+ if endpointOpts.jsonOutput {
+ return json.NewEncoder(os.Stdout).Encode(result)
+ }
+ if result.ResultLevel == "event" {
+ for _, match := range result.Events {
+ fmt.Printf("%s\t#%d\t%s\t%s\n", match.Trace.ID, match.Event.Number, match.Event.Type, traceFirstNonEmpty(match.Snippet, match.Event.Title, match.Event.Summary))
+ }
+ } else {
+ for _, trace := range result.Traces {
+ fmt.Printf("%s\t%s\t%s\n", trace.ID, trace.Harness.Name, trace.Title)
+ }
+ }
+ return nil
+ },
+}
+
+var endpointTracesShowCmd = &cobra.Command{
+ Use: "show <trace-id>",
+ Short: "Show events from one local trace",
+ Args: cobra.ExactArgs(1),
+ SilenceUsage: true,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ result, ok, err := dashboard.ShowTrace(endpointTraceLogPath(), args[0], endpointTraceQuery())
+ if err != nil {
+ return err
+ }
+ if !ok {
+ return fmt.Errorf("trace not found: %s", args[0])
+ }
+ if endpointOpts.jsonOutput {
+ return json.NewEncoder(os.Stdout).Encode(result)
+ }
+ fmt.Printf("%s\t%s\n", result.Trace.ID, result.Trace.Title)
+ for _, event := range result.Events {
+ fmt.Printf("#%d\t%s\t%s\n", event.Number, event.Type, traceFirstNonEmpty(event.Title, event.Summary))
+ if event.Content != nil && event.Content.Text != "" {
+ fmt.Println(indentTraceText(event.Content.Text))
+ }
+ if event.Command != nil && event.Command.Command != "" {
+ fmt.Println(indentTraceText(event.Command.Command))
+ }
+ }
+ if result.Range.ReturnedEvents < result.Range.TotalEvents {
+ fmt.Printf("Showing %d of %d events from offset %d.\n", result.Range.ReturnedEvents, result.Range.TotalEvents, result.Range.Offset)
+ }
+ return nil
+ },
+}
+
+func endpointTraceLogPath() string {
+ runtimeLog := lifecycle.ResolveRuntimeLog(endpointUserMode(), endpointOpts.logPath)
+ return runtimeLog.EffectiveLogPath
+}
+
+func endpointTraceQuery() dashboard.TraceQuery {
+ return dashboard.TraceQuery{
+ EventQuery: dashboard.EventQuery{Q: endpointTraceOpts.query},
+ Limit: endpointTraceOpts.limit,
+ Page: endpointTraceOpts.page,
+ State: endpointTraceOpts.state,
+ Visibility: endpointTraceOpts.visibility,
+ ResultLevel: endpointTraceOpts.resultLevel,
+ Offset: endpointTraceOpts.offset,
+ AroundEvent: endpointTraceOpts.aroundEvent,
+ Before: endpointTraceOpts.before,
+ After: endpointTraceOpts.after,
+ EventTypes: splitCSV(endpointTraceOpts.eventTypes),
+ }
+}
+
+func indentTraceText(text string) string {
+ lines := strings.Split(strings.TrimSpace(text), "\n")
+ for i, line := range lines {
+ lines[i] = " " + line
+ }
+ return strings.Join(lines, "\n")
+}
+
+func traceFirstNonEmpty(values ...string) string {
+ for _, value := range values {
+ if strings.TrimSpace(value) != "" {
+ return strings.TrimSpace(value)
+ }
+ }
+ return ""
+}
diff --git a/cli/beacon/internal/endpoint/dashboard/trace_store.go b/cli/beacon/internal/endpoint/dashboard/trace_store.go
new file mode 100644
index 00000000..6f2d8c85
--- /dev/null
+++ b/cli/beacon/internal/endpoint/dashboard/trace_store.go
@@ -0,0 +1,759 @@
+package dashboard
+
+import (
+ "database/sql"
+ "encoding/json"
+ "fmt"
+ "os"
+ "path/filepath"
+ "regexp"
+ "sort"
+ "strings"
+ "time"
+
+ _ "modernc.org/sqlite"
+)
+
+const traceStoreFile = "traces.db"
+
+type traceStore struct {
+ dbPath string
+ logPath string
+}
+
+type traceStoreStatus struct {
+ Path string `json:"path"`
+ Traces int `json:"traces"`
+ Events int `json:"events"`
+ IndexRows int `json:"index_rows"`
+ IndexedAt string `json:"indexed_at,omitempty"`
+}
+
+type traceSearchOptions struct {
+ Literal bool
+ CaseSensitive bool
+ Sources []string
+ Tool string
+ ScanTraces int
+ ScanEventsPerTrace int
+}
+
+func TraceStorePath(logPath string) string {
+ return defaultTraceStorePath(logPath)
+}
+
+func TraceStoreStatus(logPath string) (traceStoreStatus, error) {
+ return openTraceStore(logPath).Status()
+}
+
+func ReindexTraceStore(logPath string) error {
+ return openTraceStore(logPath).Reindex()
+}
+
+func defaultTraceStorePath(logPath string) string {
+ if strings.TrimSpace(logPath) == "" {
+ return traceStoreFile
+ }
+ dir := filepath.Dir(logPath)
+ if filepath.Base(dir) == "logs" {
+ return filepath.Join(filepath.Dir(dir), traceStoreFile)
+ }
+ return filepath.Join(dir, traceStoreFile)
+}
+
+func openTraceStore(logPath string) *traceStore {
+ return &traceStore{dbPath: defaultTraceStorePath(logPath), logPath: logPath}
+}
+
+func (s *traceStore) db() (*sql.DB, error) {
+ if err := os.MkdirAll(filepath.Dir(s.dbPath), 0700); err != nil {
+ return nil, err
+ }
+ db, err := sql.Open("sqlite", sqliteURI(s.dbPath))
+ if err != nil {
+ return nil, err
+ }
+ if _, err := db.Exec(`PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000;`); err != nil {
+ _ = db.Close()
+ return nil, err
+ }
+ if err := ensureTraceStoreSchema(db); err != nil {
+ _ = db.Close()
+ return nil, err
+ }
+ return db, nil
+}
+
+func sqliteURI(path string) string {
+ abs, err := filepath.Abs(path)
+ if err != nil {
+ abs = path
+ }
+ return "file:" + filepath.ToSlash(abs) + "?_pragma=busy_timeout(5000)"
+}
+
+func ensureTraceStoreSchema(db *sql.DB) error {
+ stmts := []string{
+ `CREATE TABLE IF NOT EXISTS trace_index_state (
+ source_key TEXT PRIMARY KEY,
+ fingerprint TEXT NOT NULL,
+ indexed_at TEXT NOT NULL
+ )`,
+ `CREATE TABLE IF NOT EXISTS traces (
+ id TEXT PRIMARY KEY,
+ source_key TEXT NOT NULL,
+ summary_json TEXT NOT NULL,
+ updated_at TEXT,
+ created_at TEXT NOT NULL
+ )`,
+ `CREATE INDEX IF NOT EXISTS traces_by_source_updated ON traces (source_key, updated_at DESC)`,
+ `CREATE TABLE IF NOT EXISTS trace_events (
+ trace_id TEXT NOT NULL,
+ event_id TEXT NOT NULL,
+ event_number INTEGER NOT NULL,
+ event_type TEXT,
+ tool_name TEXT,
+ event_json TEXT NOT NULL,
+ created_at TEXT NOT NULL,
+ PRIMARY KEY (trace_id, event_id)
+ )`,
+ `CREATE INDEX IF NOT EXISTS trace_events_by_trace_number ON trace_events (trace_id, event_number)`,
+ `CREATE TABLE IF NOT EXISTS trace_search (
+ trace_id TEXT NOT NULL,
+ event_id TEXT,
+ source TEXT NOT NULL,
+ event_type TEXT,
+ tool_name TEXT,
+ event_number INTEGER,
+ body TEXT NOT NULL
+ )`,
+ `CREATE INDEX IF NOT EXISTS trace_search_by_trace_source ON trace_search (trace_id, source)`,
+ `CREATE INDEX IF NOT EXISTS trace_search_by_event_type ON trace_search (event_type)`,
+ }
+ for _, stmt := range stmts {
+ if _, err := db.Exec(stmt); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (s *traceStore) ensureCurrent() error {
+ db, err := s.db()
+ if err != nil {
+ return err
+ }
+ defer db.Close()
+ fingerprint := traceLogFingerprint(s.logPath)
+ var current string
+ err = db.QueryRow(`SELECT fingerprint FROM trace_index_state WHERE source_key = ?`, s.logPath).Scan(&current)
+ if err == nil && current == fingerprint {
+ return nil
+ }
+ if err != nil && err != sql.ErrNoRows {
+ return err
+ }
+ return s.reindexDB(db, fingerprint)
+}
+
+func (s *traceStore) Reindex() error {
+ db, err := s.db()
+ if err != nil {
+ return err
+ }
+ defer db.Close()
+ return s.reindexDB(db, traceLogFingerprint(s.logPath))
+}
+
+func (s *traceStore) reindexDB(db *sql.DB, fingerprint string) error {
+ traces, err := readTraceAggregates(s.logPath, EventQuery{})
+ if err != nil {
+ return err
+ }
+ tx, err := db.Begin()
+ if err != nil {
+ return err
+ }
+ defer tx.Rollback()
+ for _, stmt := range []string{
+ `DELETE FROM trace_search WHERE trace_id IN (SELECT id FROM traces WHERE source_key = ?)`,
+ `DELETE FROM trace_events WHERE trace_id IN (SELECT id FROM traces WHERE source_key = ?)`,
+ `DELETE FROM traces WHERE source_key = ?`,
+ } {
+ if _, err := tx.Exec(stmt, s.logPath); err != nil {
+ return err
+ }
+ }
+ now := time.Now().UTC().Format(time.RFC3339Nano)
+ for _, agg := range traces {
+ if err := insertTraceAggregate(tx, s.logPath, agg, now); err != nil {
+ return err
+ }
+ }
+ if _, err := tx.Exec(`INSERT INTO trace_index_state (source_key, fingerprint, indexed_at) VALUES (?, ?, ?)
+ ON CONFLICT(source_key) DO UPDATE SET fingerprint = excluded.fingerprint, indexed_at = excluded.indexed_at`,
+ s.logPath, fingerprint, now); err != nil {
+ return err
+ }
+ return tx.Commit()
+}
+
+func insertTraceAggregate(tx *sql.Tx, sourceKey string, agg *traceAggregate, now string) error {
+ summaryJSON, err := json.Marshal(agg.summary)
+ if err != nil {
+ return err
+ }
+ if _, err := tx.Exec(`INSERT INTO traces (id, source_key, summary_json, updated_at, created_at) VALUES (?, ?, ?, ?, ?)`,
+ agg.summary.ID, sourceKey, string(summaryJSON), agg.summary.UpdatedAt, now); err != nil {
+ return err
+ }
+ if _, err := tx.Exec(`INSERT INTO trace_search (trace_id, source, body) VALUES (?, 'trace', ?)`,
+ agg.summary.ID, traceSummarySearchBody(agg.summary)); err != nil {
+ return err
+ }
+ for _, event := range agg.events {
+ eventJSON, err := json.Marshal(event)
+ if err != nil {
+ return err
+ }
+ toolName := ""
+ if event.Tool != nil {
+ toolName = event.Tool.Name
+ }
+ if event.Command != nil && toolName == "" {
+ toolName = "command"
+ }
+ if _, err := tx.Exec(`INSERT INTO trace_events (trace_id, event_id, event_number, event_type, tool_name, event_json, created_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?)`,
+ agg.summary.ID, event.ID, event.Number, event.Type, toolName, string(eventJSON), now); err != nil {
+ return err
+ }
+ if _, err := tx.Exec(`INSERT INTO trace_search (trace_id, event_id, source, event_type, tool_name, event_number, body)
+ VALUES (?, ?, 'event', ?, ?, ?, ?)`,
+ agg.summary.ID, event.ID, event.Type, toolName, event.Number, traceEventSearchBody(event)); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (s *traceStore) Status() (traceStoreStatus, error) {
+ if err := s.ensureCurrent(); err != nil {
+ return traceStoreStatus{}, err
+ }
+ db, err := s.db()
+ if err != nil {
+ return traceStoreStatus{}, err
+ }
+ defer db.Close()
+ status := traceStoreStatus{Path: s.dbPath}
+ _ = db.QueryRow(`SELECT COUNT(*) FROM traces WHERE source_key = ?`, s.logPath).Scan(&status.Traces)
+ _ = db.QueryRow(`SELECT COUNT(*) FROM trace_events WHERE trace_id IN (SELECT id FROM traces WHERE source_key = ?)`, s.logPath).Scan(&status.Events)
+ _ = db.QueryRow(`SELECT COUNT(*) FROM trace_search WHERE trace_id IN (SELECT id FROM traces WHERE source_key = ?)`, s.logPath).Scan(&status.IndexRows)
+ _ = db.QueryRow(`SELECT indexed_at FROM trace_index_state WHERE source_key = ?`, s.logPath).Scan(&status.IndexedAt)
+ return status, nil
+}
+
+func (s *traceStore) List(query TraceQuery) (TraceListResultV1, error) {
+ if !traceStoreSupportsQuery(query) {
+ return TraceListResultV1{}, errTraceStoreUnsupported
+ }
+ if err := s.ensureCurrent(); err != nil {
+ return TraceListResultV1{}, err
+ }
+ summaries, err := s.loadSummaries()
+ if err != nil {
+ return TraceListResultV1{}, err
+ }
+ filtered := make([]TraceSummaryV1, 0, len(summaries))
+ matchingIDs, err := s.matchingTraceIDs(query, traceSearchOptions{})
+ if err != nil {
+ return TraceListResultV1{}, err
+ }
+ for _, summary := range summaries {
+ if query.State != "" && !strings.EqualFold(summary.Sharing.State, query.State) {
+ continue
+ }
+ if query.Visibility != "" && !strings.EqualFold(summary.Sharing.Visibility, query.Visibility) {
+ continue
+ }
+ if query.Q != "" && !matchingIDs[summary.ID] {
+ continue
+ }
+ filtered = append(filtered, summary)
+ }
+ sortTraceSummaries(filtered)
+ limit := normalizeLimit(query.Limit)
+ page := query.Page
+ if page <= 0 {
+ page = 1
+ }
+ start := (page - 1) * limit
+ if start > len(filtered) {
+ start = len(filtered)
+ }
+ end := start + limit
+ if end > len(filtered) {
+ end = len(filtered)
+ }
+ return TraceListResultV1{
+ Traces: filtered[start:end],
+ TotalMatched: len(filtered),
+ Returned: end - start,
+ Limit: limit,
+ Page: page,
+ Truncated: end < len(filtered),
+ Filters: activeTraceFilters(query),
+ }, nil
+}
+
+func (s *traceStore) Search(query TraceQuery, opts traceSearchOptions) (TraceSearchResultV1, error) {
+ if !traceStoreSupportsQuery(query) {
+ return TraceSearchResultV1{}, errTraceStoreUnsupported
+ }
+ if query.ResultLevel == "" {
+ query.ResultLevel = "trace"
+ }
+ if err := s.ensureCurrent(); err != nil {
+ return TraceSearchResultV1{}, err
+ }
+ limit := normalizeLimit(query.Limit)
+ resp := TraceSearchResultV1{ResultLevel: query.ResultLevel, Limit: limit, Filters: activeTraceFilters(query)}
+ switch query.ResultLevel {
+ case "event":
+ events, err := s.searchEvents(query, opts, limit)
+ if err != nil {
+ return TraceSearchResultV1{}, err
+ }
+ resp.Events = events.returned
+ resp.TotalMatched = events.total
+ resp.Returned = len(resp.Events)
+ default:
+ resp.ResultLevel = "trace"
+ summaries, err := s.loadSummaries()
+ if err != nil {
+ return TraceSearchResultV1{}, err
+ }
+ matching, err := s.matchingTraceIDs(query, opts)
+ if err != nil {
+ return TraceSearchResultV1{}, err
+ }
+ for _, summary := range summaries {
+ if query.State != "" && !strings.EqualFold(summary.Sharing.State, query.State) {
+ continue
+ }
+ if query.Visibility != "" && !strings.EqualFold(summary.Sharing.Visibility, query.Visibility) {
+ continue
+ }
+ if query.Q != "" && !matching[summary.ID] {
+ continue
+ }
+ resp.Traces = append(resp.Traces, summary)
+ }
+ sortTraceSummaries(resp.Traces)
+ resp.TotalMatched = len(resp.Traces)
+ if len(resp.Traces) > limit {
+ resp.Traces = resp.Traces[:limit]
+ }
+ resp.Returned = len(resp.Traces)
+ }
+ return resp, nil
+}
+
+func (s *traceStore) Show(id string, query TraceQuery) (TraceShowResultV1, bool, error) {
+ if !traceStoreSupportsQuery(query) {
+ return TraceShowResultV1{}, false, errTraceStoreUnsupported
+ }
+ if err := s.ensureCurrent(); err != nil {
+ return TraceShowResultV1{}, false, err
+ }
+ db, err := s.db()
+ if err != nil {
+ return TraceShowResultV1{}, false, err
+ }
+ defer db.Close()
+ var summaryJSON string
+ err = db.QueryRow(`SELECT summary_json FROM traces WHERE source_key = ? AND id = ?`, s.logPath, id).Scan(&summaryJSON)
+ if err == sql.ErrNoRows {
+ return TraceShowResultV1{}, false, nil
+ }
+ if err != nil {
+ return TraceShowResultV1{}, false, err
+ }
+ var summary TraceSummaryV1
+ if err := json.Unmarshal([]byte(summaryJSON), &summary); err != nil {
+ return TraceShowResultV1{}, false, err
+ }
+ events, err := s.loadTraceEvents(db, id, query.EventTypes)
+ if err != nil {
+ return TraceShowResultV1{}, false, err
+ }
+ total := len(events)
+ offset, limit := traceRange(query, total)
+ end := offset - 1 + limit
+ if end > total {
+ end = total
+ }
+ if offset-1 > end {
+ end = offset - 1
+ }
+ return TraceShowResultV1{
+ Trace: summary,
+ Events: append([]TraceEventV1(nil), events[offset-1:end]...),
+ Spans: spansFromEvents(events),
+ Range: TraceRangeV1{
+ TotalEvents: total,
+ ReturnedEvents: end - (offset - 1),
+ Offset: offset,
+ Limit: limit,
+ AroundEvent: query.AroundEvent,
+ },
+ }, true, nil
+}
+
+var errTraceStoreUnsupported = fmt.Errorf("trace store does not support query")
+
+func traceStoreSupportsQuery(query TraceQuery) bool {
+ eq := query.EventQuery
+ return eq.Since.IsZero() &&
+ eq.Until.IsZero() &&
+ eq.Harness == "" &&
+ eq.Model == "" &&
+ eq.Action == "" &&
+ eq.Severity == "" &&
+ eq.Category == "" &&
+ eq.Repository == "" &&
+ eq.Session == "" &&
+ eq.Trace == "" &&
+ eq.File == "" &&
+ eq.Command == "" &&
+ eq.MCP == "" &&
+ eq.Approval == "" &&
+ eq.Decision == "" &&
+ eq.Policy == "" &&
+ eq.Review == "" &&
+ eq.WazuhLevel == "" &&
+ eq.SessionState == ""
+}
+
+func (s *traceStore) loadSummaries() ([]TraceSummaryV1, error) {
+ db, err := s.db()
+ if err != nil {
+ return nil, err
+ }
+ defer db.Close()
+ rows, err := db.Query(`SELECT summary_json FROM traces WHERE source_key = ?`, s.logPath)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ var summaries []TraceSummaryV1
+ for rows.Next() {
+ var raw string
+ if err := rows.Scan(&raw); err != nil {
+ return nil, err
+ }
+ var summary TraceSummaryV1
+ if err := json.Unmarshal([]byte(raw), &summary); err != nil {
+ return nil, err
+ }
+ summaries = append(summaries, summary)
+ }
+ return summaries, rows.Err()
+}
+
+func (s *traceStore) matchingTraceIDs(query TraceQuery, opts traceSearchOptions) (map[string]bool, error) {
+ out := map[string]bool{}
+ needle := strings.TrimSpace(query.Q)
+ if needle == "" {
+ return out, nil
+ }
+ db, err := s.db()
+ if err != nil {
+ return nil, err
+ }
+ defer db.Close()
+ rows, err := db.Query(`SELECT trace_id, body FROM trace_search WHERE trace_id IN (SELECT id FROM traces WHERE source_key = ?) AND source IN (`+sourcePlaceholders(opts.Sources)+`)`, append([]interface{}{s.logPath}, sourcesOrDefault(opts.Sources)...)...)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ for rows.Next() {
+ var id, body string
+ if err := rows.Scan(&id, &body); err != nil {
+ return nil, err
+ }
+ if textMatches(body, needle, opts.Literal, opts.CaseSensitive) {
+ out[id] = true
+ }
+ }
+ return out, rows.Err()
+}
+
+type traceEventSearchRows struct {
+ returned []TraceEventMatchV1
+ total int
+}
+
+func (s *traceStore) searchEvents(query TraceQuery, opts traceSearchOptions, limit int) (traceEventSearchRows, error) {
+ db, err := s.db()
+ if err != nil {
+ return traceEventSearchRows{}, err
+ }
+ defer db.Close()
+ summaries, err := s.loadSummaries()
+ if err != nil {
+ return traceEventSearchRows{}, err
+ }
+ sortTraceSummaries(summaries)
+ result := traceEventSearchRows{}
+ allowedTypes := traceEventTypeSet(query.EventTypes)
+ for _, summary := range summaries {
+ if query.State != "" && !strings.EqualFold(summary.Sharing.State, query.State) {
+ continue
+ }
+ if query.Visibility != "" && !strings.EqualFold(summary.Sharing.Visibility, query.Visibility) {
+ continue
+ }
+ events, err := s.loadTraceEvents(db, summary.ID, nil)
+ if err != nil {
+ return traceEventSearchRows{}, err
+ }
+ for _, event := range events {
+ if query.Q != "" && !textMatches(traceEventSearchBody(event), query.Q, opts.Literal, opts.CaseSensitive) {
+ continue
+ }
+ if len(allowedTypes) > 0 && !allowedTypes[traceEventTypeAlias(event.Type)] && !allowedTypes[strings.ToLower(event.Type)] {
+ continue
+ }
+ if opts.Tool != "" && (event.Tool == nil || !strings.EqualFold(event.Tool.Name, opts.Tool)) {
+ continue
+ }
+ result.total++
+ if len(result.returned) < limit {
+ result.returned = append(result.returned, TraceEventMatchV1{
+ Trace: summary,
+ Event: event,
+ Snippet: traceSnippet(event, query.Q),
+ Score: 1,
+ })
+ }
+ }
+ }
+ return result, nil
+}
+
+func (s *traceStore) loadTraceEvents(db *sql.DB, traceID string, eventTypes []string) ([]TraceEventV1, error) {
+ rows, err := db.Query(`SELECT event_json FROM trace_events WHERE trace_id = ? ORDER BY event_number`, traceID)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ allowed := traceEventTypeSet(eventTypes)
+ var events []TraceEventV1
+ for rows.Next() {
+ var raw string
+ if err := rows.Scan(&raw); err != nil {
+ return nil, err
+ }
+ var event TraceEventV1
+ if err := json.Unmarshal([]byte(raw), &event); err != nil {
+ return nil, err
+ }
+ if len(allowed) == 0 || allowed[strings.ToLower(event.Type)] || allowed[traceEventTypeAlias(event.Type)] {
+ events = append(events, event)
+ }
+ }
+ return events, rows.Err()
+}
+
+func (s *traceStore) loadOneEvent(db *sql.DB, traceID, eventID string) (TraceEventV1, bool, error) {
+ var raw string
+ err := db.QueryRow(`SELECT event_json FROM trace_events WHERE trace_id = ? AND event_id = ?`, traceID, eventID).Scan(&raw)
+ if err == sql.ErrNoRows {
+ return TraceEventV1{}, false, nil
+ }
+ if err != nil {
+ return TraceEventV1{}, false, err
+ }
+ var event TraceEventV1
+ if err := json.Unmarshal([]byte(raw), &event); err != nil {
+ return TraceEventV1{}, false, err
+ }
+ return event, true, nil
+}
+
+func spansFromEvents(events []TraceEventV1) []TraceSpanV1 {
+ spans := map[string]*TraceSpanV1{}
+ for _, event := range events {
+ if event.Trace == nil || event.Trace.SpanID == "" {
+ continue
+ }
+ span := spans[event.Trace.SpanID]
+ if span == nil {
+ span = &TraceSpanV1{ID: event.Trace.SpanID, ParentSpanID: event.Trace.ParentSpanID, TraceID: event.Trace.ID}
+ spans[event.Trace.SpanID] = span
+ }
+ if span.Name == "" {
+ span.Name = firstNonEmpty(event.Summary, event.Title, event.Action)
+ }
+ span.EventIDs = append(span.EventIDs, event.ID)
+ }
+ return traceSpanList(spans)
+}
+
+func traceLogFingerprint(logPath string) string {
+ parts := []string{}
+ for _, source := range eventSources(logPath) {
+ info, err := os.Stat(source.path)
+ if err != nil {
+ continue
+ }
+ parts = append(parts, fmt.Sprintf("%s:%d:%d", source.path, info.Size(), info.ModTime().UnixNano()))
+ }
+ sort.Strings(parts)
+ return strings.Join(parts, "|")
+}
+
+func traceSummarySearchBody(summary TraceSummaryV1) string {
+ fields := []string{
+ summary.ID,
+ summary.Title,
+ summary.Preview,
+ summary.Harness.Name,
+ summary.Harness.Version,
+ summary.Sharing.State,
+ summary.Sharing.Visibility,
+ summary.Sharing.URL,
+ }
+ if summary.Session != nil {
+ fields = append(fields, summary.Session.ID, summary.Session.WorkingDirectory)
+ }
+ if summary.Repository != nil {
+ fields = append(fields, summary.Repository.RemoteURL, summary.Repository.Branch, summary.Repository.Ref, summary.Repository.Path)
+ }
+ if summary.Namespace != nil {
+ fields = append(fields, summary.Namespace.ID, summary.Namespace.Slug, summary.Namespace.Name)
+ }
+ if summary.Trace != nil {
+ fields = append(fields, summary.Trace.ID, summary.Trace.RootSpanID)
+ }
+ return strings.Join(fields, " ")
+}
+
+func traceEventSearchBody(event TraceEventV1) string {
+ fields := []string{event.ID, event.Type, event.Action, event.Category, event.Actor, event.Title, event.Summary, event.Model}
+ if event.Content != nil {
+ fields = append(fields, event.Content.Text, event.Content.Hash)
+ }
+ if event.Tool != nil {
+ fields = append(fields, event.Tool.Name, event.Tool.Command, event.Tool.Path, fmt.Sprint(event.Tool.Arguments), fmt.Sprint(event.Tool.Result))
+ }
+ if event.Command != nil {
+ fields = append(fields, event.Command.Command)
+ if event.Command.Output != nil {
+ fields = append(fields, event.Command.Output.Text)
+ }
+ }
+ if event.File != nil {
+ fields = append(fields, event.File.Path, event.File.Operation, event.File.Language, event.File.DiffHash)
+ if event.File.Diff != nil {
+ fields = append(fields, event.File.Diff.Text)
+ }
+ }
+ if event.MCP != nil {
+ fields = append(fields, event.MCP.Server, event.MCP.Tool, event.MCP.Method, event.MCP.ResourceURI)
+ }
+ if event.Approval != nil {
+ fields = append(fields, event.Approval.Decision, event.Approval.Reason)
+ }
+ return strings.Join(fields, " ")
+}
+
+func textMatches(body, pattern string, literal, caseSensitive bool) bool {
+ body = strings.TrimSpace(body)
+ pattern = strings.TrimSpace(pattern)
+ if pattern == "" {
+ return true
+ }
+ if literal {
+ if caseSensitive {
+ return strings.Contains(body, pattern)
+ }
+ return strings.Contains(strings.ToLower(body), strings.ToLower(pattern))
+ }
+ expr := pattern
+ if !caseSensitive {
+ expr = "(?i)" + expr
+ }
+ re, err := regexp.Compile(expr)
+ if err != nil {
+ if caseSensitive {
+ return strings.Contains(body, pattern)
+ }
+ return strings.Contains(strings.ToLower(body), strings.ToLower(pattern))
+ }
+ return re.MatchString(body)
+}
+
+func sourcePlaceholders(sources []string) string {
+ values := sourcesOrDefault(sources)
+ out := make([]string, len(values))
+ for i := range out {
+ out[i] = "?"
+ }
+ return strings.Join(out, ",")
+}
+
+func sourcesOrDefault(sources []string) []interface{} {
+ if len(sources) == 0 {
+ return []interface{}{"trace", "event"}
+ }
+ out := make([]interface{}, 0, len(sources))
+ for _, source := range sources {
+ source = strings.ToLower(strings.TrimSpace(source))
+ if source == "trace" || source == "event" {
+ out = append(out, source)
+ }
+ }
+ if len(out) == 0 {
+ return []interface{}{"trace", "event"}
+ }
+ return out
+}
+
+func traceEventTypeSet(values []string) map[string]bool {
+ if len(values) == 0 {
+ return nil
+ }
+ out := map[string]bool{}
+ for _, value := range values {
+ value = strings.ToLower(strings.TrimSpace(value))
+ if value == "" {
+ continue
+ }
+ out[value] = true
+ switch value {
+ case "agent_text":
+ out["agent_message"] = true
+ case "agent_thinking":
+ out["agent_reasoning"] = true
+ case "agent_message":
+ out["agent_text"] = true
+ case "agent_reasoning":
+ out["agent_thinking"] = true
+ }
+ }
+ return out
+}
+
+func traceEventTypeAlias(value string) string {
+ switch strings.ToLower(value) {
+ case "agent_message":
+ return "agent_text"
+ case "agent_reasoning":
+ return "agent_thinking"
+ default:
+ return strings.ToLower(value)
+ }
+}
diff --git a/cli/beacon/internal/endpoint/dashboard/traces.go b/cli/beacon/internal/endpoint/dashboard/traces.go
index d5ada57b..5946d343 100644
--- a/cli/beacon/internal/endpoint/dashboard/traces.go
+++ b/cli/beacon/internal/endpoint/dashboard/traces.go
@@ -67,6 +67,9 @@ type traceAggregate struct {
}
func ReadTraceList(path string, query TraceQuery) (TraceListResultV1, error) {
+ if result, err := openTraceStore(path).List(query); err == nil {
+ return result, nil
+ }
traces, err := readTraceAggregates(path, withoutFreeText(query.EventQuery))
if err != nil {
return TraceListResultV1{}, err
@@ -107,6 +110,9 @@ func ReadTraceList(path string, query TraceQuery) (TraceListResultV1, error) {
}
func SearchTraces(path string, query TraceQuery) (TraceSearchResultV1, error) {
+ if result, err := openTraceStore(path).Search(query, traceSearchOptions{}); err == nil {
+ return result, nil
+ }
if query.ResultLevel == "" {
query.ResultLevel = "trace"
}
@@ -164,6 +170,9 @@ func SearchTraces(path string, query TraceQuery) (TraceSearchResultV1, error) {
}
func ShowTrace(path, id string, query TraceQuery) (TraceShowResultV1, bool, error) {
+ if result, ok, err := openTraceStore(path).Show(id, query); err == nil {
+ return result, ok, nil
+ }
traces, err := readTraceAggregates(path, withoutFreeText(query.EventQuery))
if err != nil {
return TraceShowResultV1{}, false, err
@@ -786,13 +795,10 @@ func filterTraceEvents(events []TraceEventV1, eventTypes []string) []TraceEventV
if len(eventTypes) == 0 {
return events
}
- allowed := map[string]bool{}
- for _, eventType := range eventTypes {
- allowed[strings.ToLower(strings.TrimSpace(eventType))] = true
- }
+ allowed := traceEventTypeSet(eventTypes)
out := make([]TraceEventV1, 0, len(events))
for _, event := range events {
- if allowed[strings.ToLower(event.Type)] {
+ if allowed[strings.ToLower(event.Type)] || allowed[traceEventTypeAlias(event.Type)] {
out = append(out, event)
}
}
diff --git a/cli/beacon/internal/endpoint/dashboard/traces_test.go b/cli/beacon/internal/endpoint/dashboard/traces_test.go
index cc69d284..77e704c5 100644
--- a/cli/beacon/internal/endpoint/dashboard/traces_test.go
+++ b/cli/beacon/internal/endpoint/dashboard/traces_test.go
@@ -4,6 +4,7 @@ import (
"encoding/json"
"net/http"
"net/http/httptest"
+ "os"
"path/filepath"
"strings"
"testing"
@@ -376,4 +377,53 @@ func TestFreeTextSelectsTracesWithoutDroppingTheirEvents(t *testing.T) {
}
}
+func TestTraceStoreIndexesAndRefreshesRuntimeLog(t *testing.T) {
+ path := filepath.Join(t.TempDir(), "logs", "runtime.jsonl")
+ if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil {
+ t.Fatalf("mkdir log dir: %v", err)
+ }
+ prompt := testSchemaEvent("2026-06-11T10:00:00Z", "cursor", "prompt.submitted", "prompt", "repo-a")
+ prompt.Event.ID = "evt-prompt"
+ prompt.Session = &schema.SessionInfo{ID: "s1", WorkingDirectory: "/repo/a"}
+ prompt.Prompt = &schema.PromptInfo{Text: "Index local traces"}
+ command := testSchemaEvent("2026-06-11T10:01:00Z", "cursor", "command.executed", "command", "repo-a")
+ command.Event.ID = "evt-command"
+ command.Session = prompt.Session
+ command.Command = &schema.CommandInfo{Command: "go test ./internal/endpoint/dashboard"}
+ writeTestLog(t, path, marshalEvents(t, prompt, command)...)
+
+ status, err := TraceStoreStatus(path)
+ if err != nil {
+ t.Fatalf("TraceStoreStatus returned error: %v", err)
+ }
+ if status.Path != filepath.Join(filepath.Dir(filepath.Dir(path)), "traces.db") {
+ t.Fatalf("trace store path = %q", status.Path)
+ }
+ if status.Traces != 1 || status.Events != 2 || status.IndexRows != 3 {
+ t.Fatalf("status = %#v, want 1 trace, 2 events, 3 index rows", status)
+ }
+
+ results, err := SearchTraces(path, TraceQuery{EventQuery: EventQuery{Q: "dashboard"}, ResultLevel: "event", Limit: 10})
+ if err != nil {
+ t.Fatalf("SearchTraces returned error: %v", err)
+ }
+ if results.TotalMatched != 1 || len(results.Events) != 1 || results.Events[0].Event.ID != "evt-command" {
+ t.Fatalf("indexed search results = %#v", results)
+ }
+
+ later := testSchemaEvent("2026-06-11T10:02:00Z", "cursor", "file.modified", "file", "repo-a")
+ later.Event.ID = "evt-file"
+ later.Session = prompt.Session
+ later.File = &schema.FileInfo{Path: "trace_store.go", Operation: "modify"}
+ writeTestLog(t, path, marshalEvents(t, prompt, command, later)...)
+
+ status, err = TraceStoreStatus(path)
+ if err != nil {
+ t.Fatalf("TraceStoreStatus after refresh returned error: %v", err)
+ }
+ if status.Events != 3 || status.IndexRows != 4 {
+ t.Fatalf("refreshed status = %#v, want 3 events and 4 index rows", status)
+ }
+}
+
func int64Ptr(v int64) *int64 { return &v }