Wire up the components with main

cmd/signozcollector/main.go

@@ -1,43 +1,96 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"log"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
 
-	"github.com/SigNoz/signoz-otel-collector/components"
-	"go.opentelemetry.io/collector/component"
-	"go.opentelemetry.io/collector/service"
+	"github.com/SigNoz/signoz-otel-collector/service"
+	"github.com/SigNoz/signoz-otel-collector/signozcol"
+	flag "github.com/spf13/pflag"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
 )
 
 func main() {
 
-	factories, err := components.Components()
+	// Command line flags
+	f := flag.NewFlagSet("Collector CLI Options", flag.ExitOnError)
+
+	f.Usage = func() {
+		fmt.Println(f.FlagUsages())
+		os.Exit(0)
+	}
+
+	f.String("config", "", "File path for the collector configuration")
+	f.String("manager-config", "", "File path for the agent manager configuration")
+	err := f.Parse(os.Args[1:])
 	if err != nil {
-		log.Fatalf("failed to build default components: %v", err)
+		log.Fatalf("Failed to parse args %v", err)
 	}
 
-	info := component.BuildInfo{
-		Command:     "signoz-otel-collector",
-		Description: "SigNoz OTEL Collector",
-		Version:     "latest",
+	collectorConfig, _ := f.GetString("config")
+	managerConfig, _ := f.GetString("manager-config")
+
+	// logger, err := zap.NewProduction()
+	logger, err := initZapLog()
+	if err != nil {
+		log.Fatalf("failed to initialize zap logger: %v", err)
 	}
 
-	params := service.CollectorSettings{
-		Factories: factories,
-		BuildInfo: info,
+	ctx := context.Background()
+
+	coll := signozcol.New(
+		signozcol.WrappedCollectorSettings{
+			ConfigPaths: []string{collectorConfig},
+			// TODO: Build version from git tag
+			Version:     "0.63.0",
+			Desc:        "SigNoz OpenTelemetry Collector",
+			LoggingOpts: []zap.Option{zap.WithCaller(true)},
+		},
+	)
+
+	svc, err := service.New(coll, logger, managerConfig, collectorConfig)
+	if err != nil {
+		log.Fatalf("failed to create collector service: %v", err)
 	}
 
-	if err := run(params); err != nil {
-		log.Fatal(err)
+	ctx, cancel := signal.NotifyContext(ctx, syscall.SIGINT, syscall.SIGTERM)
+	defer cancel()
+
+	if err := runInteractive(ctx, logger, svc); err != nil {
+		log.Fatalf("failed to run service: %v", err)
 	}
 }
 
-func runInteractive(params service.CollectorSettings) error {
-	cmd := service.NewCommand(params)
-	err := cmd.Execute()
-	if err != nil {
-		return fmt.Errorf("application run finished with error: %w", err)
+func runInteractive(ctx context.Context, logger *zap.Logger, svc service.Service) error {
+	if err := svc.Start(ctx); err != nil {
+		return fmt.Errorf("failed to start collector service: %w", err)
+	}
+
+	select {
+	case <-ctx.Done():
+	}
+
+	stopTimeoutCtx, stopCancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer stopCancel()
+
+	if err := svc.Shutdown(stopTimeoutCtx); err != nil {
+		return fmt.Errorf("failed to stop service: %w", err)
 	}
 
 	return nil
 }
+
+func initZapLog() (*zap.Logger, error) {
+	config := zap.NewDevelopmentConfig()
+	config.EncoderConfig.EncodeLevel = zapcore.LowercaseLevelEncoder
+	config.EncoderConfig.TimeKey = "timestamp"
+	config.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
+	logger, err := config.Build()
+	return logger, err
+}

config/default-manager-config.yaml

@@ -0,0 +1 @@
+server_endpoint: ws://127.0.0.1:4320/v1/opamp