The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
add trace local db
Justin D'Souza929eda6ee092
diff --git a/cli/beacon/cmd/endpoint.go b/cli/beacon/cmd/endpoint.goindex 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.gonew file mode 100644index 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.gonew file mode 100644index 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(¤t)+ 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.goindex 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) []TraceEventVif 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.goindex 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 }