diff --git a/.gitignore b/.gitignore
index ac20e6b..6922ba8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,9 @@
+# Binaries
+hal
+
+# Test coverage
 cover.out
+
+# Databases
 sqlite.db*
 test-results.json
diff --git a/cmd/hal/commands/stats.go b/cmd/hal/commands/stats.go
new file mode 100644
index 0000000..15a48d4
--- /dev/null
+++ b/cmd/hal/commands/stats.go
@@ -0,0 +1,174 @@
+package commands
+
+import (
+	"fmt"
+	"math"
+	"os"
+	"sort"
+	"strings"
+	"text/tabwriter"
+	"time"
+
+	"github.com/dansimau/hal/store"
+	"github.com/spf13/cobra"
+	"gorm.io/gorm"
+)
+
+type MetricSummary struct {
+	MetricType store.MetricType
+	LastMinute interface{}
+	LastHour   interface{}
+	LastDay    interface{}
+	LastMonth  interface{}
+}
+
+type TimePeriod struct {
+	Name     string
+	Duration time.Duration
+}
+
+// NewStatsCmd creates the stats command
+func NewStatsCmd() *cobra.Command {
+	var dbPath string
+
+	cmd := &cobra.Command{
+		Use:     "stats",
+		Aliases: []string{"stat"},
+		Short:   "Display HAL metrics statistics",
+		Long: `Display comprehensive metrics statistics for HAL automation system.
+Shows automation triggers, evaluations, and processing times across multiple time periods.`,
+		Example: `  hal stats                    # Show stats using default database
+  hal stats --db custom.db     # Show stats from custom database`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runStatsCommand(dbPath)
+		},
+	}
+
+	cmd.Flags().StringVar(&dbPath, "db", "sqlite.db", "Database file path")
+	return cmd
+}
+
+func runStatsCommand(dbPath string) error {
+	// Open database connection
+	db, err := store.Open(dbPath)
+	if err != nil {
+		return fmt.Errorf("failed to open database: %w", err)
+	}
+
+	// Get stats for all metric types
+	metricTypes := []store.MetricType{
+		store.MetricTypeAutomationTriggered,
+		store.MetricTypeTickProcessingTime,
+	}
+
+	var summaries []MetricSummary
+
+	for _, metricType := range metricTypes {
+		summary := MetricSummary{MetricType: metricType}
+
+		if strings.Contains(string(metricType), "time") {
+			// Timer metrics - calculate p99
+			summary.LastMinute = calculateP99(db, metricType, time.Minute)
+			summary.LastHour = calculateP99(db, metricType, time.Hour)
+			summary.LastDay = calculateP99(db, metricType, 24*time.Hour)
+			summary.LastMonth = calculateP99(db, metricType, 30*24*time.Hour)
+		} else {
+			// Counter metrics - sum
+			summary.LastMinute = sumMetrics(db, metricType, time.Minute)
+			summary.LastHour = sumMetrics(db, metricType, time.Hour)
+			summary.LastDay = sumMetrics(db, metricType, 24*time.Hour)
+			summary.LastMonth = sumMetrics(db, metricType, 30*24*time.Hour)
+		}
+
+		summaries = append(summaries, summary)
+	}
+
+	// Print results in table format
+	return printTable(summaries)
+}
+
+func sumMetrics(db *gorm.DB, metricType store.MetricType, duration time.Duration) int64 {
+	since := time.Now().Add(-duration)
+	var result struct {
+		Total int64
+	}
+
+	db.Model(&store.Metric{}).
+		Select("COALESCE(SUM(value), 0) as total").
+		Where("metric_type = ? AND timestamp > ?", metricType, since).
+		Scan(&result)
+
+	return result.Total
+}
+
+func calculateP99(db *gorm.DB, metricType store.MetricType, duration time.Duration) string {
+	since := time.Now().Add(-duration)
+	var values []int64
+
+	db.Model(&store.Metric{}).
+		Select("value").
+		Where("metric_type = ? AND timestamp > ?", metricType, since).
+		Scan(&values)
+
+	if len(values) == 0 {
+		return "0ms"
+	}
+
+	sort.Slice(values, func(i, j int) bool {
+		return values[i] < values[j]
+	})
+
+	// Calculate p99 (99th percentile)
+	index := int(math.Ceil(float64(len(values))*0.99)) - 1
+	if index < 0 {
+		index = 0
+	}
+
+	p99Nanos := values[index]
+	return formatDuration(time.Duration(p99Nanos))
+}
+
+func formatDuration(d time.Duration) string {
+	if d < time.Microsecond {
+		return fmt.Sprintf("%.0fns", float64(d))
+	} else if d < time.Millisecond {
+		return fmt.Sprintf("%.1fμs", float64(d)/float64(time.Microsecond))
+	} else if d < time.Second {
+		return fmt.Sprintf("%.1fms", float64(d)/float64(time.Millisecond))
+	} else {
+		return fmt.Sprintf("%.2fs", d.Seconds())
+	}
+}
+
+func formatMetricType(metricType store.MetricType) string {
+	switch metricType {
+	case store.MetricTypeAutomationTriggered:
+		return "Automations Triggered"
+	case store.MetricTypeTickProcessingTime:
+		return "Tick Processing Time (p99)"
+	default:
+		return string(metricType)
+	}
+}
+
+func printTable(summaries []MetricSummary) error {
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	defer w.Flush()
+
+	// Print header
+	fmt.Fprintf(w, "Metric\tLast Minute\tLast Hour\tLast Day\tLast Month\n")
+	fmt.Fprintf(w, "------\t-----------\t---------\t--------\t----------\n")
+
+	// Print data rows
+	for _, summary := range summaries {
+		fmt.Fprintf(w, "%s\t%v\t%v\t%v\t%v\n",
+			formatMetricType(summary.MetricType),
+			summary.LastMinute,
+			summary.LastHour,
+			summary.LastDay,
+			summary.LastMonth,
+		)
+	}
+
+	return nil
+}
diff --git a/cmd/hal/commands/stats_test.go b/cmd/hal/commands/stats_test.go
new file mode 100644
index 0000000..a5d6d0b
--- /dev/null
+++ b/cmd/hal/commands/stats_test.go
@@ -0,0 +1,274 @@
+package commands
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/dansimau/hal/store"
+	"github.com/spf13/cobra"
+	"gorm.io/gorm"
+	"gotest.tools/v3/assert"
+)
+
+func setupTestDBForStats(t *testing.T) *gorm.DB {
+	t.Helper()
+
+	db, err := store.Open(":memory:")
+	assert.NilError(t, err)
+
+	return db
+}
+
+func captureOutput(f func()) string {
+	old := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	f()
+
+	w.Close()
+	os.Stdout = old
+
+	var buf bytes.Buffer
+	io.Copy(&buf, r)
+	return buf.String()
+}
+
+func TestNewStatsCmd(t *testing.T) {
+	cmd := NewStatsCmd()
+
+	assert.Equal(t, cmd.Use, "stats")
+	assert.Assert(t, len(cmd.Aliases) > 0)
+	assert.Equal(t, cmd.Aliases[0], "stat")
+	assert.Assert(t, strings.Contains(cmd.Short, "metrics"))
+	assert.Assert(t, strings.Contains(cmd.Long, "automation"))
+}
+
+func TestStatsCommandWithEmptyDatabase(t *testing.T) {
+	// Create temporary database file for testing
+	tempFile := t.TempDir() + "/test.db"
+	tempDB, err := store.Open(tempFile)
+	assert.NilError(t, err)
+
+	// Close the temp database so the command can open it
+	sqlDB, err := tempDB.DB()
+	assert.NilError(t, err)
+	sqlDB.Close()
+
+	// Capture output
+	output := captureOutput(func() {
+		err := runStatsCommand(tempFile)
+		assert.NilError(t, err)
+	})
+
+	// Verify expected output format
+	lines := strings.Split(strings.TrimSpace(output), "\n")
+	assert.Assert(t, len(lines) >= 3) // Header, separator, at least one data row
+
+	// Check header
+	assert.Assert(t, strings.Contains(lines[0], "Metric"))
+	assert.Assert(t, strings.Contains(lines[0], "Last Minute"))
+	assert.Assert(t, strings.Contains(lines[0], "Last Hour"))
+
+	// Check that empty database shows zeros
+	assert.Assert(t, strings.Contains(output, "0"))
+	assert.Assert(t, strings.Contains(output, "0ms"))
+}
+
+func TestStatsCommandWithSampleData(t *testing.T) {
+	// Create temporary database file
+	tempFile := t.TempDir() + "/test_with_data.db"
+	db, err := store.Open(tempFile)
+	assert.NilError(t, err)
+
+	// Insert sample metrics
+	now := time.Now()
+	sampleMetrics := []store.Metric{
+		{
+			Timestamp:      now.Add(-30 * time.Second),
+			MetricType:     store.MetricTypeAutomationTriggered,
+			Value:          1,
+			EntityID:       "test.light",
+			AutomationName: "motion_light",
+		},
+		{
+			Timestamp:      now.Add(-1 * time.Minute),
+			MetricType:     store.MetricTypeTickProcessingTime,
+			Value:          (150 * time.Millisecond).Nanoseconds(),
+			EntityID:       "test.sensor",
+			AutomationName: "",
+		},
+		{
+			Timestamp:      now.Add(-10 * time.Minute),
+			MetricType:     store.MetricTypeTickProcessingTime,
+			Value:          (75 * time.Millisecond).Nanoseconds(),
+			EntityID:       "test.light",
+			AutomationName: "",
+		},
+	}
+
+	for _, metric := range sampleMetrics {
+		assert.NilError(t, db.Create(&metric).Error)
+	}
+
+	// Close database so command can open it
+	sqlDB, err := db.DB()
+	assert.NilError(t, err)
+	sqlDB.Close()
+
+	// Capture output
+	output := captureOutput(func() {
+		err := runStatsCommand(tempFile)
+		assert.NilError(t, err)
+	})
+
+	// Verify output contains expected data
+	assert.Assert(t, strings.Contains(output, "Automations Triggered"))
+	assert.Assert(t, strings.Contains(output, "Tick Processing Time"))
+
+	// Should show non-zero values for recent metrics
+	lines := strings.Split(output, "\n")
+	foundTriggerLine := false
+	foundTimeLine := false
+
+	for _, line := range lines {
+		if strings.Contains(line, "Automations Triggered") {
+			foundTriggerLine = true
+			// Should show 1 trigger in last minute - check for any non-zero number
+			assert.Assert(t, strings.Contains(line, "1") || strings.Contains(line, "2"), "Expected trigger count in line: %s", line)
+		}
+		if strings.Contains(line, "Tick Processing Time") {
+			foundTimeLine = true
+			// Should show processing time in milliseconds
+			assert.Assert(t, strings.Contains(line, "ms"), "Expected ms in time line: %s", line)
+		}
+	}
+
+	assert.Assert(t, foundTriggerLine, "Expected to find Automations Triggered line")
+	assert.Assert(t, foundTimeLine, "Expected to find Tick Processing Time line")
+}
+
+func TestFormatDuration(t *testing.T) {
+	testCases := []struct {
+		duration time.Duration
+		expected string
+	}{
+		{500 * time.Nanosecond, "500ns"},
+		{1500 * time.Nanosecond, "1.5μs"},
+		{time.Duration(2500), "2.5μs"},
+		{time.Duration(1.5 * float64(time.Millisecond)), "1.5ms"},
+		{150 * time.Millisecond, "150.0ms"},
+		{2500 * time.Millisecond, "2.50s"},
+	}
+
+	for _, tc := range testCases {
+		result := formatDuration(tc.duration)
+		assert.Equal(t, result, tc.expected, "Duration: %v", tc.duration)
+	}
+}
+
+func TestFormatMetricType(t *testing.T) {
+	testCases := []struct {
+		metricType store.MetricType
+		expected   string
+	}{
+		{store.MetricTypeAutomationTriggered, "Automations Triggered"},
+		{store.MetricTypeTickProcessingTime, "Tick Processing Time (p99)"},
+		{store.MetricType("unknown_metric"), "unknown_metric"},
+	}
+
+	for _, tc := range testCases {
+		result := formatMetricType(tc.metricType)
+		assert.Equal(t, result, tc.expected)
+	}
+}
+
+func TestSumMetrics(t *testing.T) {
+	db := setupTestDBForStats(t)
+
+	now := time.Now()
+	// Insert metrics within and outside the time window
+	metrics := []store.Metric{
+		{
+			Timestamp:  now.Add(-30 * time.Second), // Within 1 minute
+			MetricType: store.MetricTypeAutomationTriggered,
+			Value:      1,
+		},
+		{
+			Timestamp:  now.Add(-45 * time.Second), // Within 1 minute
+			MetricType: store.MetricTypeAutomationTriggered,
+			Value:      1,
+		},
+		{
+			Timestamp:  now.Add(-2 * time.Minute), // Outside 1 minute window
+			MetricType: store.MetricTypeAutomationTriggered,
+			Value:      1,
+		},
+	}
+
+	for _, metric := range metrics {
+		assert.NilError(t, db.Create(&metric).Error)
+	}
+
+	// Test sum for last minute (should be 2)
+	result := sumMetrics(db, store.MetricTypeAutomationTriggered, time.Minute)
+	assert.Equal(t, result, int64(2))
+
+	// Test sum for last 5 minutes (should be 3)
+	result = sumMetrics(db, store.MetricTypeAutomationTriggered, 5*time.Minute)
+	assert.Equal(t, result, int64(3))
+}
+
+func TestCalculateP99(t *testing.T) {
+	db := setupTestDBForStats(t)
+
+	now := time.Now()
+	// Insert timer metrics with various values
+	values := []int64{
+		(10 * time.Millisecond).Nanoseconds(),
+		(20 * time.Millisecond).Nanoseconds(),
+		(30 * time.Millisecond).Nanoseconds(),
+		(40 * time.Millisecond).Nanoseconds(),
+		(100 * time.Millisecond).Nanoseconds(), // This should be p99
+	}
+
+	for _, value := range values {
+		metric := store.Metric{
+			Timestamp:  now.Add(-30 * time.Second),
+			MetricType: store.MetricTypeTickProcessingTime,
+			Value:      value,
+		}
+		assert.NilError(t, db.Create(&metric).Error)
+	}
+
+	// Calculate p99
+	result := calculateP99(db, store.MetricTypeTickProcessingTime, time.Minute)
+
+	// Should return the highest value (100ms) as p99
+	assert.Equal(t, result, "100.0ms")
+}
+
+func TestCalculateP99EmptyDataset(t *testing.T) {
+	db := setupTestDBForStats(t)
+
+	// Test with empty dataset
+	result := calculateP99(db, store.MetricTypeTickProcessingTime, time.Minute)
+	assert.Equal(t, result, "0ms")
+}
+
+func TestStatsCommandCobraIntegration(t *testing.T) {
+	cmd := NewStatsCmd()
+
+	// Test that command can be executed (though it may fail due to missing database)
+	rootCmd := &cobra.Command{Use: "test"}
+	rootCmd.AddCommand(cmd)
+
+	// Test help output
+	rootCmd.SetArgs([]string{"stats", "--help"})
+	err := rootCmd.Execute()
+	assert.NilError(t, err)
+}
diff --git a/cmd/hal/main.go b/cmd/hal/main.go
new file mode 100644
index 0000000..1d62280
--- /dev/null
+++ b/cmd/hal/main.go
@@ -0,0 +1,25 @@
+package main
+
+import (
+	"os"
+
+	"github.com/dansimau/hal/cmd/hal/commands"
+	"github.com/spf13/cobra"
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "hal",
+	Short: "HAL - Home Automation Library CLI",
+	Long: `HAL is a comprehensive home automation library that connects to Home Assistant
+and provides powerful automation capabilities with built-in metrics and monitoring.`,
+}
+
+func main() {
+	if err := rootCmd.Execute(); err != nil {
+		os.Exit(1)
+	}
+}
+
+func init() {
+	rootCmd.AddCommand(commands.NewStatsCmd())
+}
\ No newline at end of file
diff --git a/connection.go b/connection.go
index ae23c96..88c5293 100644
--- a/connection.go
+++ b/connection.go
@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/dansimau/hal/hassws"
+	"github.com/dansimau/hal/metrics"
 	"github.com/dansimau/hal/perf"
 	"github.com/dansimau/hal/store"
 	"github.com/google/go-cmp/cmp"
@@ -28,7 +29,8 @@ type Connection struct {
 	// Lock to serialize state updates and ensure automations fire in order.
 	mutex sync.RWMutex
 
-	homeAssistant *hassws.Client
+	homeAssistant  *hassws.Client
+	metricsService *metrics.Service
 
 	*SunTimes
 }
@@ -56,9 +58,10 @@ func NewConnection(cfg Config) *Connection {
 	})
 
 	return &Connection{
-		config:        cfg,
-		db:            db,
-		homeAssistant: api,
+		config:         cfg,
+		db:             db,
+		homeAssistant:  api,
+		metricsService: metrics.NewService(db),
 
 		automations: make(map[string][]Automation),
 		entities:    make(map[string]EntityInterface),
@@ -103,6 +106,9 @@ func (h *Connection) RegisterEntities(entities ...EntityInterface) {
 
 // Start connects to the Home Assistant websocket and starts listening for events.
 func (h *Connection) Start() error {
+	// Start metrics service
+	h.metricsService.Start()
+
 	if err := h.homeAssistant.Connect(); err != nil {
 		return err
 	}
@@ -119,6 +125,7 @@ func (h *Connection) Start() error {
 }
 
 func (h *Connection) Close() {
+	h.metricsService.Stop()
 	h.homeAssistant.Close()
 }
 
@@ -151,6 +158,8 @@ func (h *Connection) syncStates() error {
 func (h *Connection) StateChangeEvent(event hassws.EventMessage) {
 	defer perf.Timer(func(timeTaken time.Duration) {
 		slog.Debug("Tick processing time", "duration", timeTaken)
+		// Record tick processing time metric
+		h.metricsService.RecordTimer(store.MetricTypeTickProcessingTime, timeTaken, event.Event.EventData.EntityID, "")
 	})()
 
 	h.mutex.Lock()
@@ -192,6 +201,8 @@ func (h *Connection) StateChangeEvent(event hassws.EventMessage) {
 	// Dispatch automations
 	for _, automation := range h.automations[event.Event.EventData.EntityID] {
 		slog.Info("Running automation", "name", automation.Name())
+		// Record automation triggered metric
+		h.metricsService.RecordCounter(store.MetricTypeAutomationTriggered, event.Event.EventData.EntityID, automation.Name())
 		automation.Action(entity)
 	}
 }
diff --git a/connection_metrics_test.go b/connection_metrics_test.go
new file mode 100644
index 0000000..08fb03d
--- /dev/null
+++ b/connection_metrics_test.go
@@ -0,0 +1,147 @@
+package hal_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/dansimau/hal"
+	"github.com/dansimau/hal/homeassistant"
+	"github.com/dansimau/hal/testutil"
+	"gotest.tools/v3/assert"
+)
+
+func TestMetricsInstrumentation(t *testing.T) {
+	conn, server, cleanup := testutil.NewClientServer(t)
+	defer cleanup()
+
+	// Create test entities
+	sensor := hal.NewBinarySensor("test.motion_sensor")
+	light := hal.NewLight("test.light")
+	conn.RegisterEntities(sensor, light)
+
+	// Create test automation
+	automation := hal.NewAutomation().
+		WithName("motion_light_automation").
+		WithEntities(sensor).
+		WithAction(func(trigger hal.EntityInterface) {
+			light.TurnOn()
+		})
+	
+	conn.RegisterAutomations(automation)
+
+	// Trigger a state change that will run automation
+	server.SendEvent(homeassistant.Event{
+		EventType: "state_changed",
+		EventData: homeassistant.EventData{
+			EntityID: "test.motion_sensor",
+			NewState: &homeassistant.State{State: "on"},
+		},
+	})
+
+	// Wait for processing
+	time.Sleep(50 * time.Millisecond)
+
+	// Test passes if no errors/panics occurred during metrics collection
+	// The detailed metric verification is done in the metrics package tests
+}
+
+func TestMetricsAutomationTriggered(t *testing.T) {
+	conn, server, cleanup := testutil.NewClientServer(t)
+	defer cleanup()
+
+	// Create test entities and automation
+	sensor := hal.NewBinarySensor("test.sensor")
+	conn.RegisterEntities(sensor)
+
+	var automationExecuted bool
+	automation := hal.NewAutomation().
+		WithName("test_automation").
+		WithEntities(sensor).
+		WithAction(func(trigger hal.EntityInterface) {
+			automationExecuted = true
+		})
+	
+	conn.RegisterAutomations(automation)
+
+	// Trigger automation
+	server.SendEvent(homeassistant.Event{
+		EventType: "state_changed",
+		EventData: homeassistant.EventData{
+			EntityID: "test.sensor",
+			NewState: &homeassistant.State{State: "on"},
+		},
+	})
+	time.Sleep(10 * time.Millisecond)
+
+	// Verify automation was triggered (which means metrics were collected)
+	assert.Assert(t, automationExecuted, "Expected automation to be triggered")
+}
+
+func TestMetricsIntegrationBasicScenarios(t *testing.T) {
+	conn, server, cleanup := testutil.NewClientServer(t)
+	defer cleanup()
+
+	// Create test entities
+	sensor := hal.NewBinarySensor("test.sensor")
+	light1 := hal.NewLight("test.light1")
+	light2 := hal.NewLight("test.light2")
+	conn.RegisterEntities(sensor, light1, light2)
+
+	// Create multiple automations for the same trigger
+	var automation1Executed, automation2Executed bool
+	
+	automation1 := hal.NewAutomation().
+		WithName("automation_1").
+		WithEntities(sensor).
+		WithAction(func(trigger hal.EntityInterface) {
+			automation1Executed = true
+			light1.TurnOn()
+		})
+	
+	automation2 := hal.NewAutomation().
+		WithName("automation_2").
+		WithEntities(sensor).
+		WithAction(func(trigger hal.EntityInterface) {
+			automation2Executed = true
+			light2.TurnOn()
+		})
+	
+	conn.RegisterAutomations(automation1, automation2)
+
+	// Test normal state change (should trigger automations and record metrics)
+	server.SendEvent(homeassistant.Event{
+		EventType: "state_changed",
+		EventData: homeassistant.EventData{
+			EntityID: "test.sensor",
+			NewState: &homeassistant.State{State: "on"},
+		},
+	})
+	time.Sleep(50 * time.Millisecond)
+
+	// Verify both automations were triggered
+	assert.Assert(t, automation1Executed, "Expected automation 1 to be triggered")
+	assert.Assert(t, automation2Executed, "Expected automation 2 to be triggered")
+	
+	// Reset for next test
+	automation1Executed = false
+	automation2Executed = false
+
+	// Test state change from HAL's own user (should NOT trigger automations)
+	server.SendEvent(homeassistant.Event{
+		EventType: "state_changed",
+		EventData: homeassistant.EventData{
+			EntityID: "test.sensor",
+			NewState: &homeassistant.State{State: "off"},
+		},
+		Context: homeassistant.EventMessageContext{
+			UserID: testutil.TestUserID,
+		},
+	})
+	time.Sleep(50 * time.Millisecond)
+
+	// Verify automations were NOT triggered (loop protection)
+	assert.Assert(t, !automation1Executed, "Expected automation 1 NOT to be triggered for own actions")
+	assert.Assert(t, !automation2Executed, "Expected automation 2 NOT to be triggered for own actions")
+	
+	// If we get here without panics/errors, metrics collection is working properly
+}
\ No newline at end of file
diff --git a/go.mod b/go.mod
index 8feddb2..8cca60d 100644
--- a/go.mod
+++ b/go.mod
@@ -19,10 +19,13 @@ require (
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/glebarez/go-sqlite v1.21.2 // indirect
 	github.com/google/uuid v1.3.0 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/mattn/go-isatty v0.0.17 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/spf13/cobra v1.9.1 // indirect
+	github.com/spf13/pflag v1.0.6 // indirect
 	golang.org/x/sys v0.7.0 // indirect
 	golang.org/x/text v0.14.0 // indirect
 	modernc.org/libc v1.22.5 // indirect
diff --git a/go.sum b/go.sum
index 53e5a4a..b423413 100644
--- a/go.sum
+++ b/go.sum
@@ -1,5 +1,6 @@
 github.com/benbjohnson/clock v1.3.5 h1:VvXlSJBzZpA/zum6Sj74hxwYI2DIxRWuNIoXAzHZz5o=
 github.com/benbjohnson/clock v1.3.5/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
+github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
@@ -16,6 +17,8 @@ github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
@@ -27,6 +30,11 @@ github.com/nathan-osman/go-sunrise v1.1.0/go.mod h1:RcWqhT+5ShCZDev79GuWLayetpJp
 github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
+github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
+github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
+github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
 golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
diff --git a/metrics/service.go b/metrics/service.go
new file mode 100644
index 0000000..23da4ca
--- /dev/null
+++ b/metrics/service.go
@@ -0,0 +1,93 @@
+package metrics
+
+import (
+	"log/slog"
+	"time"
+
+	"github.com/dansimau/hal/store"
+	"gorm.io/gorm"
+)
+
+// Service handles metrics collection and pruning
+// Writes directly to SQLite, leveraging SQLite's WAL mode for performance
+type Service struct {
+	db            *gorm.DB
+	pruneInterval time.Duration // How often to prune old metrics (default: daily)
+	retentionTime time.Duration // How long to keep metrics (default: 3 months)
+	stopChan      chan struct{}
+}
+
+// NewService creates a new metrics service
+func NewService(db *gorm.DB) *Service {
+	return &Service{
+		db:            db,
+		pruneInterval: 24 * time.Hour,     // Prune daily
+		retentionTime: 90 * 24 * time.Hour, // Keep 3 months of metrics
+		stopChan:      make(chan struct{}),
+	}
+}
+
+// Start begins the metrics pruning goroutine
+func (s *Service) Start() {
+	go s.pruneMetrics()
+	slog.Info("Metrics service started")
+}
+
+// Stop stops the metrics service
+func (s *Service) Stop() {
+	close(s.stopChan)
+	slog.Info("Metrics service stopped")
+}
+
+// RecordCounter records a counter metric (value = 1)
+// Writes directly to SQLite, leveraging WAL mode for performance
+func (s *Service) RecordCounter(metricType store.MetricType, entityID, automationName string) {
+	metric := store.Metric{
+		Timestamp:      time.Now(),
+		MetricType:     metricType,
+		Value:          1,
+		EntityID:       entityID,
+		AutomationName: automationName,
+	}
+	
+	if err := s.db.Create(&metric).Error; err != nil {
+		slog.Error("Failed to record counter metric", "error", err, "type", metricType)
+	}
+}
+
+// RecordTimer records a timer metric (value = duration in nanoseconds)
+// Writes directly to SQLite, leveraging WAL mode for performance
+func (s *Service) RecordTimer(metricType store.MetricType, duration time.Duration, entityID, automationName string) {
+	metric := store.Metric{
+		Timestamp:      time.Now(),
+		MetricType:     metricType,
+		Value:          duration.Nanoseconds(),
+		EntityID:       entityID,
+		AutomationName: automationName,
+	}
+	
+	if err := s.db.Create(&metric).Error; err != nil {
+		slog.Error("Failed to record timer metric", "error", err, "type", metricType)
+	}
+}
+
+// pruneMetrics runs in a goroutine to periodically remove old metrics
+func (s *Service) pruneMetrics() {
+	ticker := time.NewTicker(s.pruneInterval)
+	defer ticker.Stop()
+	
+	for {
+		select {
+		case <-s.stopChan:
+			return
+		case <-ticker.C:
+			cutoffTime := time.Now().Add(-s.retentionTime)
+			result := s.db.Where("timestamp < ?", cutoffTime).Delete(&store.Metric{})
+			if result.Error != nil {
+				slog.Error("Failed to prune old metrics", "error", result.Error)
+			} else if result.RowsAffected > 0 {
+				slog.Info("Pruned old metrics", "count", result.RowsAffected, "cutoff", cutoffTime)
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/metrics/service_test.go b/metrics/service_test.go
new file mode 100644
index 0000000..c92367b
--- /dev/null
+++ b/metrics/service_test.go
@@ -0,0 +1,152 @@
+package metrics
+
+import (
+	"testing"
+	"time"
+
+	"github.com/dansimau/hal/store"
+	"gorm.io/gorm"
+	"gotest.tools/v3/assert"
+)
+
+func setupTestDB(t *testing.T) *gorm.DB {
+	t.Helper()
+	
+	// Use a temporary file database instead of in-memory to avoid concurrency issues
+	dbPath := t.TempDir() + "/test.db"
+	db, err := store.Open(dbPath)
+	assert.NilError(t, err)
+	
+	// Ensure the Metric table is created (store.Open should handle this via AutoMigrate)
+	// But let's be explicit for tests
+	err = db.AutoMigrate(&store.Metric{})
+	assert.NilError(t, err)
+	
+	return db
+}
+
+func TestNewService(t *testing.T) {
+	db := setupTestDB(t)
+	service := NewService(db)
+	
+	assert.Assert(t, service != nil)
+	assert.Equal(t, service.pruneInterval, 24*time.Hour)
+	assert.Equal(t, service.retentionTime, 90*24*time.Hour) // 3 months
+}
+
+func TestRecordCounter(t *testing.T) {
+	db := setupTestDB(t)
+	service := NewService(db)
+	
+	// Record a counter metric (writes directly to database)
+	service.RecordCounter(store.MetricTypeAutomationTriggered, "test.entity", "test automation")
+	
+	// Verify metric was recorded
+	var metrics []store.Metric
+	result := db.Find(&metrics)
+	assert.NilError(t, result.Error)
+	assert.Equal(t, len(metrics), 1)
+	
+	savedMetric := metrics[0]
+	assert.Equal(t, savedMetric.MetricType, store.MetricTypeAutomationTriggered)
+	assert.Equal(t, savedMetric.Value, int64(1))
+	assert.Equal(t, savedMetric.EntityID, "test.entity")
+	assert.Equal(t, savedMetric.AutomationName, "test automation")
+	assert.Assert(t, !savedMetric.Timestamp.IsZero())
+}
+
+func TestRecordTimer(t *testing.T) {
+	db := setupTestDB(t)
+	service := NewService(db)
+	
+	duration := 150 * time.Millisecond
+	
+	// Record a timer metric (writes directly to database)
+	service.RecordTimer(store.MetricTypeTickProcessingTime, duration, "test.entity", "")
+	
+	// Verify metric was recorded
+	var metrics []store.Metric
+	result := db.Find(&metrics)
+	assert.NilError(t, result.Error)
+	assert.Equal(t, len(metrics), 1)
+	
+	metric := metrics[0]
+	assert.Equal(t, metric.MetricType, store.MetricTypeTickProcessingTime)
+	assert.Equal(t, metric.Value, duration.Nanoseconds())
+	assert.Equal(t, metric.EntityID, "test.entity")
+	assert.Equal(t, metric.AutomationName, "")
+}
+
+func TestMultipleMetrics(t *testing.T) {
+	db := setupTestDB(t)
+	service := NewService(db)
+	
+	// Record multiple metrics (writes directly to database)
+	service.RecordCounter(store.MetricTypeAutomationTriggered, "entity1", "automation1")
+	service.RecordCounter(store.MetricTypeAutomationTriggered, "entity2", "automation2")
+	service.RecordCounter(store.MetricTypeAutomationTriggered, "entity3", "automation3")
+	
+	// Verify all metrics were recorded
+	var count int64
+	db.Model(&store.Metric{}).Count(&count)
+	assert.Equal(t, count, int64(3))
+}
+
+func TestPruneOldMetrics(t *testing.T) {
+	db := setupTestDB(t)
+	service := NewService(db)
+	
+	// Create old and new metrics (100 days old vs 1 hour old)
+	oldTime := time.Now().Add(-100 * 24 * time.Hour) // 100 days old (older than 90 day retention)
+	newTime := time.Now().Add(-1 * time.Hour)        // 1 hour old
+	
+	oldMetric := store.Metric{
+		Timestamp:  oldTime,
+		MetricType: store.MetricTypeAutomationTriggered,
+		Value:      1,
+	}
+	
+	newMetric := store.Metric{
+		Timestamp:  newTime,
+		MetricType: store.MetricTypeAutomationTriggered,
+		Value:      1,
+	}
+	
+	// Insert metrics directly into database
+	assert.NilError(t, db.Create(&oldMetric).Error)
+	assert.NilError(t, db.Create(&newMetric).Error)
+	
+	// Verify both metrics exist
+	var count int64
+	db.Model(&store.Metric{}).Count(&count)
+	assert.Equal(t, count, int64(2))
+	
+	// Manually trigger pruning with the default retention time (90 days)
+	cutoffTime := time.Now().Add(-service.retentionTime)
+	result := db.Where("timestamp < ?", cutoffTime).Delete(&store.Metric{})
+	assert.NilError(t, result.Error)
+	
+	// Only new metric should remain
+	db.Model(&store.Metric{}).Count(&count)
+	assert.Equal(t, count, int64(1))
+	
+	// Verify it's the new metric
+	var remaining store.Metric
+	db.First(&remaining)
+	assert.Assert(t, remaining.Timestamp.After(cutoffTime))
+}
+
+func TestServiceStartStop(t *testing.T) {
+	db := setupTestDB(t)
+	service := NewService(db)
+	
+	// Test that service can start and stop cleanly
+	service.Start()
+	
+	// Brief pause to let pruning goroutine start
+	time.Sleep(10 * time.Millisecond)
+	
+	service.Stop()
+	
+	// Verify no errors occurred (success is just clean start/stop)
+}
\ No newline at end of file
diff --git a/store/models.go b/store/models.go
index b618c6f..19c02ce 100644
--- a/store/models.go
+++ b/store/models.go
@@ -18,3 +18,22 @@ type Entity struct {
 	Type  string
 	State *homeassistant.State `gorm:"serializer:json"`
 }
+
+// MetricType represents the type of metric being recorded
+type MetricType string
+
+// MetricType constants
+const (
+	MetricTypeAutomationTriggered MetricType = "automation_triggered"
+	MetricTypeTickProcessingTime  MetricType = "tick_processing_time"
+)
+
+// Metric represents a single metric data point
+type Metric struct {
+	ID             uint       `gorm:"primaryKey;autoIncrement"`
+	Timestamp      time.Time  `gorm:"index;not null"`
+	MetricType     MetricType `gorm:"not null;size:50"`
+	Value          int64      `gorm:"not null"` // For counters: 1, for timers: nanoseconds
+	EntityID       string     `gorm:"size:100"` // Optional: which entity triggered this
+	AutomationName string     `gorm:"size:100"` // Optional: which automation was involved
+}
diff --git a/store/sqlite.go b/store/sqlite.go
index 7c31737..839b590 100644
--- a/store/sqlite.go
+++ b/store/sqlite.go
@@ -19,7 +19,7 @@ func Open(path string) (*gorm.DB, error) {
 		return nil, err
 	}
 
-	if err := db.AutoMigrate(&Entity{}); err != nil {
+	if err := db.AutoMigrate(&Entity{}, &Metric{}); err != nil {
 		return nil, err
 	}
 
diff --git a/testutil/testutil.go b/testutil/testutil.go
index 555517c..75da7e5 100644
--- a/testutil/testutil.go
+++ b/testutil/testutil.go
@@ -25,7 +25,7 @@ func NewClientServer(t *testing.T) (*hal.Connection, *hassws.Server, func()) {
 	server, err := hassws.NewServer(validUsers)
 	assert.NilError(t, err)
 
-	// Create client and connection
+	// Create client and connection with unique test database
 	conn := hal.NewConnection(hal.Config{
 		HomeAssistant: hal.HomeAssistantConfig{
 			Host:   server.ListenAddress(),