feat(factory): introduce factories

conf/defaults.yaml → conf/example.yaml

@@ -3,8 +3,36 @@
 # Do not modify this file
 #
 
+##################### Instrumentation #####################
+instrumentation:
+  logs:
+    level: info
+    enabled: false
+    processors:
+      batch:
+        exporter:
+          otlp:
+            endpoint: localhost:4317
+  traces:
+    enabled: false
+    processors:
+      batch:
+        exporter:
+          otlp:
+            endpoint: localhost:4317
+  metrics:
+    enabled: true
+    readers:
+      pull:
+        exporter:
+          prometheus:
+            host: "0.0.0.0"
+            port: 9090
+
 ##################### Web #####################
 web:
+  # Whether to enable the web frontend
+  enabled: true
   # The prefix to serve web on
   prefix: /
   # The directory containing the static build files.
@@ -29,4 +57,14 @@ cache:
     # The password for authenticating with the Redis server, if required.
     password: 
     # The Redis database number to use
-    db: 0
+    db: 0
+
+##################### SQLStore #####################
+sqlstore:
+  # specifies the SQLStore provider to use.
+  provider: sqlite
+  # The maximum number of open connections to the database.
+  max_open_conns: 100
+  sqlite:
+    # The path to the SQLite database file.
+    path: /var/lib/signoz/signoz.db

ee/query-service/app/server.go

@@ -64,7 +64,6 @@ import (
 const AppDbEngine = "sqlite"
 
 type ServerOptions struct {
-	SigNoz            *signoz.SigNoz
 	PromConfigPath    string
 	SkipTopLvlOpsPath string
 	HTTPHostPort      string
@@ -82,7 +81,6 @@ type ServerOptions struct {
 	GatewayUrl        string
 	UseLogsNewSchema  bool
 	UseTraceNewSchema bool
-	SkipWebFrontend   bool
 }
 
 // Server runs HTTP api service
@@ -112,34 +110,23 @@ func (s Server) HealthCheckStatus() chan healthcheck.Status {
 }
 
 // NewServer creates and initializes Server
-func NewServer(serverOptions *ServerOptions) (*Server, error) {
-
-	modelDao, err := dao.InitDao("sqlite", baseconst.RELATIONAL_DATASOURCE_PATH)
-	if err != nil {
-		return nil, err
-	}
-
-	baseexplorer.InitWithDSN(baseconst.RELATIONAL_DATASOURCE_PATH)
-
-	if err := preferences.InitDB(baseconst.RELATIONAL_DATASOURCE_PATH); err != nil {
-		return nil, err
-	}
-
-	localDB, err := dashboards.InitDB(baseconst.RELATIONAL_DATASOURCE_PATH)
-
+func NewServer(serverOptions *ServerOptions, config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
+	modelDao, err := dao.InitDao(signoz.SQLStore.SQLxDB())
 	if err != nil {
 		return nil, err
 	}
 
-	localDB.SetMaxOpenConns(10)
+	baseexplorer.InitWithDB(signoz.SQLStore.SQLxDB())
+	preferences.InitDB(signoz.SQLStore.SQLxDB())
+	dashboards.InitDB(signoz.SQLStore.SQLxDB())
 
 	gatewayProxy, err := gateway.NewProxy(serverOptions.GatewayUrl, gateway.RoutePrefix)
 	if err != nil {
 		return nil, err
 	}
 
 	// initiate license manager
-	lm, err := licensepkg.StartManager("sqlite", localDB)
+	lm, err := licensepkg.StartManager("sqlite", signoz.SQLStore.SQLxDB())
 	if err != nil {
 		return nil, err
 	}
@@ -153,7 +140,7 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 	if storage == "clickhouse" {
 		zap.L().Info("Using ClickHouse as datastore ...")
 		qb := db.NewDataConnector(
-			localDB,
+			signoz.SQLStore.SQLxDB(),
 			serverOptions.PromConfigPath,
 			lm,
 			serverOptions.MaxIdleConns,
@@ -189,7 +176,7 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 	rm, err := makeRulesManager(serverOptions.PromConfigPath,
 		baseconst.GetAlertManagerApiPrefix(),
 		serverOptions.RuleRepoURL,
-		localDB,
+		signoz.SQLStore.SQLxDB(),
 		reader,
 		c,
 		serverOptions.DisableRules,
@@ -210,19 +197,16 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 	}()
 
 	// initiate opamp
-	_, err = opAmpModel.InitDB(localDB)
-	if err != nil {
-		return nil, err
-	}
+	_ = opAmpModel.InitDB(signoz.SQLStore.SQLxDB())
 
-	integrationsController, err := integrations.NewController(localDB)
+	integrationsController, err := integrations.NewController(signoz.SQLStore.SQLxDB())
 	if err != nil {
 		return nil, fmt.Errorf(
 			"couldn't create integrations controller: %w", err,
 		)
 	}
 
-	cloudIntegrationsController, err := cloudintegrations.NewController(localDB)
+	cloudIntegrationsController, err := cloudintegrations.NewController(signoz.SQLStore.SQLxDB())
 	if err != nil {
 		return nil, fmt.Errorf(
 			"couldn't create cloud provider integrations controller: %w", err,
@@ -231,16 +215,15 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 
 	// ingestion pipelines manager
 	logParsingPipelineController, err := logparsingpipeline.NewLogParsingPipelinesController(
-		localDB, "sqlite", integrationsController.GetPipelinesForInstalledIntegrations,
+		signoz.SQLStore.SQLxDB(), integrationsController.GetPipelinesForInstalledIntegrations,
 	)
 	if err != nil {
 		return nil, err
 	}
 
 	// initiate agent config handler
 	agentConfMgr, err := agentConf.Initiate(&agentConf.ManagerOptions{
-		DB:            localDB,
-		DBEngine:      AppDbEngine,
+		DB:            signoz.SQLStore.SQLxDB(),
 		AgentFeatures: []agentConf.AgentFeature{logParsingPipelineController},
 	})
 	if err != nil {
@@ -302,7 +285,7 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) {
 		usageManager:       usageManager,
 	}
 
-	httpServer, err := s.createPublicServer(apiHandler, serverOptions.SigNoz.Web)
+	httpServer, err := s.createPublicServer(apiHandler, signoz.Web)
 
 	if err != nil {
 		return nil, err
@@ -351,7 +334,7 @@ func (s *Server) createPrivateServer(apiHandler *api.APIHandler) (*http.Server,
 	}, nil
 }
 
-func (s *Server) createPublicServer(apiHandler *api.APIHandler, web *web.Web) (*http.Server, error) {
+func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*http.Server, error) {
 
 	r := baseapp.NewRouter()
 
@@ -396,11 +379,9 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web *web.Web) (*
 
 	handler = handlers.CompressHandler(handler)
 
-	if !s.serverOptions.SkipWebFrontend {
-		err := web.AddToRouter(r)
-		if err != nil {
-			return nil, err
-		}
+	err := web.AddToRouter(r)
+	if err != nil {
+		return nil, err
 	}
 
 	return &http.Server{

ee/query-service/dao/factory.go

@@ -1,18 +1,11 @@
 package dao
 
 import (
-	"fmt"
-
+	"github.com/jmoiron/sqlx"
 	"go.signoz.io/signoz/ee/query-service/dao/sqlite"
 )
 
-func InitDao(engine, path string) (ModelDao, error) {
-
-	switch engine {
-	case "sqlite":
-		return sqlite.InitDB(path)
-	default:
-		return nil, fmt.Errorf("qsdb type: %s is not supported in query service", engine)
-	}
+func InitDao(inputDB *sqlx.DB) (ModelDao, error) {
+	return sqlite.InitDB(inputDB)
 
 }

ee/query-service/dao/sqlite/modelDao.go

@@ -65,8 +65,8 @@ func columnExists(db *sqlx.DB, tableName, columnName string) bool {
 }
 
 // InitDB creates and extends base model DB repository
-func InitDB(dataSourceName string) (*modelDao, error) {
-	dao, err := basedsql.InitDB(dataSourceName)
+func InitDB(inputDB *sqlx.DB) (*modelDao, error) {
+	dao, err := basedsql.InitDB(inputDB)
 	if err != nil {
 		return nil, err
 	}