feat: Implement core Argus application with OTLP ingestion, storage, and web UI.

Author: aksOps

README.md

@@ -1,5 +1,10 @@
 # Project Argus
 
+[![Latest Release](https://img.shields.io/github/v/release/RandomCodeSpace/Project-Argus)](https://github.com/RandomCodeSpace/Project-Argus/releases)
+[![Security Audit](https://github.com/RandomCodeSpace/Project-Argus/actions/workflows/audit.yml/badge.svg)](https://github.com/RandomCodeSpace/Project-Argus/actions)
+![Go Version](https://img.shields.io/github/go-mod/go-version/RandomCodeSpace/Project-Argus)
+![React](https://img.shields.io/badge/frontend-React%20v18-61dafb?logo=react)
+
 Project Argus is an integrated observability and AI analysis platform.
 
 ## Getting Started

cmd/argus/main.go

@@ -62,7 +62,7 @@ func main() {
 	slog.Info("📊 Internal telemetry initialized")
 
 	// 2. Initialize Storage
-	repo, err := storage.NewRepository()
+	repo, err := storage.NewRepository(metrics)
 	if err != nil {
 		log.Fatalf("Failed to initialize repository: %v", err)
 	}
@@ -104,8 +104,8 @@ func main() {
 	apiServer := api.NewServer(repo, hub, metrics)
 
 	// 7. Initialize OTLP Ingestion (gRPC)
-	traceServer := ingest.NewTraceServer(repo, cfg)
-	logsServer := ingest.NewLogsServer(repo, cfg)
+	traceServer := ingest.NewTraceServer(repo, metrics, cfg)
+	logsServer := ingest.NewLogsServer(repo, metrics, cfg)
 
 	// Wire up live log streaming + AI + DLQ metrics
 	logHandler := func(l storage.Log) {

internal/ingest/otlp.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/RandomCodeSpace/Project-Argus/internal/config"
 	"github.com/RandomCodeSpace/Project-Argus/internal/storage"
+	"github.com/RandomCodeSpace/Project-Argus/internal/telemetry"
 	collogspb "go.opentelemetry.io/proto/otlp/collector/logs/v1"
 	coltracepb "go.opentelemetry.io/proto/otlp/collector/trace/v1"
 	commonpb "go.opentelemetry.io/proto/otlp/common/v1"
@@ -18,6 +19,7 @@ import (
 
 type TraceServer struct {
 	repo             *storage.Repository
+	metrics          *telemetry.Metrics
 	logCallback      func(storage.Log)
 	minSeverity      int
 	allowedServices  map[string]bool
@@ -27,16 +29,18 @@ type TraceServer struct {
 
 type LogsServer struct {
 	repo             *storage.Repository
+	metrics          *telemetry.Metrics
 	logCallback      func(storage.Log)
 	minSeverity      int
 	allowedServices  map[string]bool
 	excludedServices map[string]bool
 	collogspb.UnimplementedLogsServiceServer
 }
 
-func NewTraceServer(repo *storage.Repository, cfg *config.Config) *TraceServer {
+func NewTraceServer(repo *storage.Repository, metrics *telemetry.Metrics, cfg *config.Config) *TraceServer {
 	return &TraceServer{
 		repo:             repo,
+		metrics:          metrics,
 		minSeverity:      parseSeverity(cfg.IngestMinSeverity),
 		allowedServices:  parseServiceList(cfg.IngestAllowedServices),
 		excludedServices: parseServiceList(cfg.IngestExcludedServices),
@@ -48,9 +52,10 @@ func (s *TraceServer) SetLogCallback(cb func(storage.Log)) {
 	s.logCallback = cb
 }
 
-func NewLogsServer(repo *storage.Repository, cfg *config.Config) *LogsServer {
+func NewLogsServer(repo *storage.Repository, metrics *telemetry.Metrics, cfg *config.Config) *LogsServer {
 	return &LogsServer{
 		repo:             repo,
+		metrics:          metrics,
 		minSeverity:      parseSeverity(cfg.IngestMinSeverity),
 		allowedServices:  parseServiceList(cfg.IngestAllowedServices),
 		excludedServices: parseServiceList(cfg.IngestExcludedServices),
@@ -106,6 +111,7 @@ func (s *TraceServer) Export(ctx context.Context, req *coltracepb.ExportTraceSer
 					StartTime:      startTime,
 					EndTime:        endTime,
 					Duration:       duration,
+					ServiceName:    serviceName,
 					AttributesJSON: string(attrs),
 				}
 				spansToInsert = append(spansToInsert, sModel)
@@ -226,6 +232,9 @@ func (s *TraceServer) Export(ctx context.Context, req *coltracepb.ExportTraceSer
 			return nil, err
 		}
 		// slog.Debug("✅ Successfully persisted spans", "count", len(spansToInsert))
+		if s.metrics != nil {
+			s.metrics.RecordIngestion(len(spansToInsert))
+		}
 	}
 
 	return &coltracepb.ExportTraceServiceResponse{}, nil
@@ -304,6 +313,9 @@ func (s *LogsServer) Export(ctx context.Context, req *collogspb.ExportLogsServic
 			return nil, err
 		}
 		// slog.Debug("✅ Successfully persisted logs", "count", len(logsToInsert))
+		if s.metrics != nil {
+			s.metrics.RecordIngestion(len(logsToInsert))
+		}
 	}
 
 	// Notify listener

internal/storage/models.go

@@ -33,8 +33,9 @@ type Span struct {
 	OperationName  string    `gorm:"size:255;index" json:"operation_name"`
 	StartTime      time.Time `json:"start_time"`
 	EndTime        time.Time `json:"end_time"`
-	Duration       int64     `json:"duration"`                         // Microseconds
-	AttributesJSON string    `gorm:"type:text" json:"attributes_json"` // Stored as JSON string
+	Duration       int64     `json:"duration"`                           // Microseconds
+	ServiceName    string    `gorm:"size:255;index" json:"service_name"` // Originating service
+	AttributesJSON string    `gorm:"type:text" json:"attributes_json"`   // Stored as JSON string
 }
 
 // Log represents a log entry associated with a trace.

internal/storage/repository.go

@@ -7,18 +7,20 @@ import (
 	"strings"
 	"time"
 
+	"github.com/RandomCodeSpace/Project-Argus/internal/telemetry"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 )
 
 // Repository wraps the GORM database handle for all data access operations.
 type Repository struct {
-	db     *gorm.DB
-	driver string
+	db      *gorm.DB
+	driver  string
+	metrics *telemetry.Metrics
 }
 
 // NewRepository initializes the database connection using environment variables and migrates the schema.
-func NewRepository() (*Repository, error) {
+func NewRepository(metrics *telemetry.Metrics) (*Repository, error) {
 	driver := os.Getenv("DB_DRIVER")
 	dsn := os.Getenv("DB_DSN")
 
@@ -36,7 +38,30 @@ func NewRepository() (*Repository, error) {
 		return nil, err
 	}
 
-	return &Repository{db: db, driver: driver}, nil
+	// Register GORM Callback for DB Latency Metrics
+	if metrics != nil {
+		db.Callback().Query().Before("gorm:query").Register("telemetry:before_query", func(d *gorm.DB) {
+			d.Set("telemetry:start_time", time.Now())
+		})
+		db.Callback().Query().After("gorm:query").Register("telemetry:after_query", func(d *gorm.DB) {
+			if start, ok := d.Get("telemetry:start_time"); ok {
+				duration := time.Since(start.(time.Time)).Seconds()
+				metrics.ObserveDBLatency(duration)
+			}
+		})
+		// Also measure Create/Update/Delete if desired, but Query is most frequent for "Latency"
+		db.Callback().Create().Before("gorm:create").Register("telemetry:before_create", func(d *gorm.DB) {
+			d.Set("telemetry:start_time", time.Now())
+		})
+		db.Callback().Create().After("gorm:create").Register("telemetry:after_create", func(d *gorm.DB) {
+			if start, ok := d.Get("telemetry:start_time"); ok {
+				duration := time.Since(start.(time.Time)).Seconds()
+				metrics.ObserveDBLatency(duration)
+			}
+		})
+	}
+
+	return &Repository{db: db, driver: driver, metrics: metrics}, nil
 }
 
 // BatchCreateSpans inserts multiple spans in batches.