fix(daemon): unify log profiles according to flag

backend/cmd/mintter-site/main.go

@@ -59,7 +59,7 @@ Flags:
 			return err
 		}
 
-		dir, err := storage.InitRepo(cfg.Base.DataDir, nil)
+		dir, err := storage.InitRepo(cfg.Base.DataDir, nil, cfg.LogLevel)
 		if err != nil {
 			return err
 		}

backend/cmd/mintter-site/sites/sites_test.go

@@ -122,7 +122,7 @@ func makeTestSite(t *testing.T, name string) *App {
 	user := coretest.NewTester(name)
 
 	cfg := testConfig(t)
-	dir, err := storage.InitRepo(cfg.Base.DataDir, user.Device.Wrapped())
+	dir, err := storage.InitRepo(cfg.Base.DataDir, user.Device.Wrapped(), "debug")
 	require.NoError(t, err)
 
 	app, err := Load(ctx, "http://127.0.0.1:"+strconv.Itoa(cfg.HTTP.Port), cfg, dir)

backend/cmd/mintterd/main.go

@@ -68,11 +68,11 @@ func main() {
 			defer sentry.Flush(2 * time.Second)
 		}
 
-		dir, err := storage.InitRepo(cfg.Base.DataDir, nil)
+		dir, err := storage.InitRepo(cfg.Base.DataDir, nil, cfg.LogLevel)
 		if err != nil {
 			return err
 		}
-		app, err := daemon.Load(ctx, cfg, dir,
+		app, err := daemon.Load(ctx, cfg, dir, cfg.LogLevel,
 			grpc.ChainUnaryInterceptor(
 				otelgrpc.UnaryServerInterceptor(),
 				daemon.GRPCDebugLoggingInterceptor(),

backend/cmd/mkdb/main.go

@@ -39,12 +39,12 @@ func run() error {
 		return err
 	}
 
-	dir, err := storage.InitRepo(cfg.Base.DataDir, alice.Device.Wrapped())
+	dir, err := storage.InitRepo(cfg.Base.DataDir, alice.Device.Wrapped(), cfg.LogLevel)
 	if err != nil {
 		return err
 	}
 
-	app, err := daemon.Load(ctx, cfg, dir)
+	app, err := daemon.Load(ctx, cfg, dir, "debug")
 	if err != nil {
 		return err
 	}

backend/config/config.go

@@ -70,7 +70,7 @@ func Default() Config {
 	return Config{
 		Base: Base{
 			DataDir:  "~/.mtt",
-			LogLevel: "debug",
+			LogLevel: "info",
 		},
 		HTTP: HTTP{
 			Port: 55001,

backend/daemon/api/apis.go

@@ -41,6 +41,7 @@ func New(
 	node *future.ReadOnly[*mttnet.Node],
 	sync *future.ReadOnly[*syncing.Service],
 	wallet *wallet.Service,
+	LogLevel string,
 ) Server {
 	doSync := func() error {
 		s, ok := sync.Get()
@@ -57,14 +58,14 @@ func New(
 		return nil
 	}
 
-	documentsSrv := documents.NewServer(repo.Identity(), db, &lazyDiscoverer{sync: sync, net: node})
+	documentsSrv := documents.NewServer(repo.Identity(), db, &lazyDiscoverer{sync: sync, net: node}, LogLevel)
 	return Server{
 		Accounts:   accounts.NewServer(repo.Identity(), blobs),
 		Daemon:     daemon.NewServer(repo, blobs, wallet, doSync),
 		Documents:  documentsSrv,
 		Networking: networking.NewServer(blobs, node),
 		Entities:   entities.NewServer(blobs, &lazyDiscoverer{sync: sync}),
-		Groups:     groups.NewServer(repo.Identity(), logging.New("mintter/groups", "debug"), groups.NewSQLiteDB(db), blobs, node),
+		Groups:     groups.NewServer(repo.Identity(), logging.New("mintter/groups", LogLevel), groups.NewSQLiteDB(db), blobs, node),
 	}
 }
 

backend/daemon/api/documents/v1alpha/documents.go

@@ -40,12 +40,12 @@ type Server struct {
 }
 
 // NewServer creates a new RPC handler.
-func NewServer(me *future.ReadOnly[core.Identity], db *sqlitex.Pool, disc Discoverer) *Server {
+func NewServer(me *future.ReadOnly[core.Identity], db *sqlitex.Pool, disc Discoverer, LogLevel string) *Server {
 	srv := &Server{
 		db:    db,
 		me:    me,
 		disc:  disc,
-		blobs: hyper.NewStorage(db, logging.New("mintter/hyper", "debug")),
+		blobs: hyper.NewStorage(db, logging.New("mintter/hyper", LogLevel)),
 	}
 
 	return srv
@@ -523,7 +523,7 @@ func (api *Server) ListAccountPublications(ctx context.Context, in *documents.Li
 
 		pub, err := api.GetPublication(ctx, &documents.GetPublicationRequest{
 			DocumentId: x.ResourcesIRI,
-			LocalOnly: true,
+			LocalOnly:  true,
 		})
 		if err != nil {
 			continue

backend/daemon/api/documents/v1alpha/documents_test.go

@@ -858,7 +858,7 @@ func newTestDocsAPI(t *testing.T, name string) *Server {
 	fut := future.New[core.Identity]()
 	require.NoError(t, fut.Resolve(u.Identity))
 
-	srv := NewServer(fut.ReadOnly, db, nil)
+	srv := NewServer(fut.ReadOnly, db, nil, "debug")
 	bs := hyper.NewStorage(db, logging.New("mintter/hyper", "debug"))
 	_, err := daemon.Register(context.Background(), bs, u.Account, u.Device.PublicKey, time.Now())
 	require.NoError(t, err)

backend/daemon/api/groups/v1alpha/groups.go

@@ -158,7 +158,7 @@ func (srv *Server) scheduleSiteWorkers(ctx context.Context,
 					logFunc := log.Debug
 					err := srv.syncGroupSite(ctx, group, interval)
 					if err != nil {
-						logFunc = log.Error
+						logFunc = log.Warn
 					}
 					logFunc("SiteSyncRoundFinished",
 						zap.Duration("duration", time.Since(start)),

backend/daemon/daemon.go

@@ -79,7 +79,7 @@ type App struct {
 // To shut down the app gracefully cancel the provided context and call Wait().
 func Load(ctx context.Context, cfg config.Config, r *storage.Dir, extraOpts ...interface{}) (a *App, err error) {
 	a = &App{
-		log:     logging.New("mintter/daemon", "debug"),
+		log:     logging.New("mintter/daemon", cfg.LogLevel),
 		Storage: r,
 	}
 	a.g, ctx = errgroup.WithContext(ctx)
@@ -119,32 +119,32 @@ func Load(ctx context.Context, cfg config.Config, r *storage.Dir, extraOpts ...i
 		return nil, err
 	}
 
-	a.Blobs = hyper.NewStorage(a.DB, logging.New("mintter/hyper", "debug"))
+	a.Blobs = hyper.NewStorage(a.DB, logging.New("mintter/hyper", cfg.LogLevel))
 	if err := a.Blobs.MaybeReindex(ctx); err != nil {
 		return nil, fmt.Errorf("failed to reindex database: %w", err)
 	}
 
 	me := a.Storage.Identity()
 
-	a.Net, err = initNetwork(&a.clean, a.g, me, cfg.P2P, a.DB, a.Blobs, extraOpts...)
+	a.Net, err = initNetwork(&a.clean, a.g, me, cfg.P2P, a.DB, a.Blobs, cfg.LogLevel, extraOpts...)
 	if err != nil {
 		return nil, err
 	}
 
-	a.Syncing, err = initSyncing(cfg.Syncing, &a.clean, a.g, a.DB, a.Blobs, me, a.Net)
+	a.Syncing, err = initSyncing(cfg.Syncing, &a.clean, a.g, a.DB, a.Blobs, me, a.Net, cfg.LogLevel)
 	if err != nil {
 		return nil, err
 	}
 
-	a.Wallet = wallet.New(ctx, logging.New("mintter/wallet", "debug"), a.DB, a.Net, me, cfg.Lndhub.Mainnet)
+	a.Wallet = wallet.New(ctx, logging.New("mintter/wallet", cfg.LogLevel), a.DB, a.Net, me, cfg.Lndhub.Mainnet)
 
 	extraHTTPHandlers := []GenericHandler{}
 	for _, extra := range extraOpts {
 		if httpHandler, ok := extra.(GenericHandler); ok {
 			extraHTTPHandlers = append(extraHTTPHandlers, httpHandler)
 		}
 	}
-	a.GRPCServer, a.GRPCListener, a.RPC, err = initGRPC(ctx, cfg.GRPC.Port, &a.clean, a.g, a.Storage, a.DB, a.Blobs, a.Net, a.Syncing, a.Wallet, extraOpts...)
+	a.GRPCServer, a.GRPCListener, a.RPC, err = initGRPC(ctx, cfg.GRPC.Port, &a.clean, a.g, a.Storage, a.DB, a.Blobs, a.Net, a.Syncing, a.Wallet, cfg.LogLevel, extraOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -163,7 +163,7 @@ func Load(ctx context.Context, cfg config.Config, r *storage.Dir, extraOpts ...i
 			e = offline.Exchange(bs)
 		}
 
-		files := mttnet.NewFileManager(logging.New("mintter/file-manager", "debug"), bs, e, n.Provider())
+		files := mttnet.NewFileManager(logging.New("mintter/file-manager", cfg.LogLevel), bs, e, n.Provider())
 		if err := fm.fm.Resolve(files); err != nil {
 			return err
 		}
@@ -211,8 +211,8 @@ func (l *lazyFileManager) UploadFile(w http.ResponseWriter, r *http.Request) {
 }
 
 func (a *App) setupLogging(ctx context.Context, cfg config.Config) {
-	logging.SetLogLevel("autorelay", "info")
-	logging.SetLogLevel("provider.batched", "debug")
+	logging.SetLogLevel("autorelay", cfg.LogLevel)
+	logging.SetLogLevel("provider.batched", cfg.LogLevel)
 	a.g.Go(func() error {
 		a.log.Info("DaemonStarted",
 			zap.String("grpcListener", a.GRPCListener.Addr().String()),
@@ -276,6 +276,7 @@ func initNetwork(
 	cfg config.P2P,
 	db *sqlitex.Pool,
 	blobs *hyper.Storage,
+	LogLevel string,
 	extraServers ...interface{},
 ) (*future.ReadOnly[*mttnet.Node], error) {
 	f := future.New[*mttnet.Node]()
@@ -298,7 +299,7 @@ func initNetwork(
 			return err
 		}
 
-		n, err := mttnet.New(cfg, db, blobs, id, logging.New("mintter/network", "debug"), extraServers...)
+		n, err := mttnet.New(cfg, db, blobs, id, logging.New("mintter/network", LogLevel), extraServers...)
 		if err != nil {
 			return err
 		}
@@ -333,6 +334,7 @@ func initSyncing(
 	blobs *hyper.Storage,
 	me *future.ReadOnly[core.Identity],
 	net *future.ReadOnly[*mttnet.Node],
+	LogLevel string,
 ) (*future.ReadOnly[*syncing.Service], error) {
 	f := future.New[*syncing.Service]()
 
@@ -358,7 +360,7 @@ func initSyncing(
 			return err
 		}
 
-		svc := syncing.NewService(logging.New("mintter/syncing", "debug"), id, db, blobs, node.Bitswap(), node.Client)
+		svc := syncing.NewService(logging.New("mintter/syncing", LogLevel), id, db, blobs, node.Bitswap(), node.Client)
 		svc.SetWarmupDuration(cfg.WarmupDuration)
 		svc.SetPeerSyncTimeout(cfg.TimeoutPerPeer)
 		svc.SetSyncInterval(cfg.Interval)
@@ -398,6 +400,7 @@ func initGRPC(
 	node *future.ReadOnly[*mttnet.Node],
 	sync *future.ReadOnly[*syncing.Service],
 	wallet *wallet.Service,
+	LogLevel string,
 	extras ...interface{},
 ) (srv *grpc.Server, lis net.Listener, rpc api.Server, err error) {
 	lis, err = net.Listen("tcp", ":"+strconv.Itoa(port))
@@ -413,7 +416,7 @@ func initGRPC(
 	}
 	srv = grpc.NewServer(opts...)
 
-	rpc = api.New(ctx, repo, pool, blobs, node, sync, wallet)
+	rpc = api.New(ctx, repo, pool, blobs, node, sync, wallet, LogLevel)
 	rpc.Register(srv)
 	reflection.Register(srv)
 

backend/daemon/daemon_testing.go

@@ -27,10 +27,10 @@ func makeTestApp(t *testing.T, name string, cfg config.Config, register bool) *A
 
 	u := coretest.NewTester(name)
 
-	repo, err := storage.InitRepo(cfg.Base.DataDir, u.Device.Wrapped())
+	repo, err := storage.InitRepo(cfg.Base.DataDir, u.Device.Wrapped(), "debug")
 	require.NoError(t, err)
 
-	app, err := Load(ctx, cfg, repo)
+	app, err := Load(ctx, cfg, repo, "debug")
 	require.NoError(t, err)
 	t.Cleanup(func() {
 		cancel()

backend/daemon/storage/storage.go

@@ -23,8 +23,8 @@ type Dir struct {
 
 // InitRepo initializes the storage directory.
 // Device can be nil in which case a random new device key will be generated.
-func InitRepo(dataDir string, device crypto.PrivKey) (r *Dir, err error) {
-	log := logging.New("mintter/repo", "debug")
+func InitRepo(dataDir string, device crypto.PrivKey, logLevel string) (r *Dir, err error) {
+	log := logging.New("mintter/repo", logLevel)
 	if device == nil {
 		r, err = New(dataDir, log)
 	} else {

backend/manual_test.go

@@ -27,7 +27,7 @@ func TestDBMigrateManual(t *testing.T) {
 		return
 	}
 
-	dir, err := storage.InitRepo("/tmp/mintter-db-migrate-test", nil)
+	dir, err := storage.InitRepo("/tmp/mintter-db-migrate-test", nil, "debug")
 	require.NoError(t, err)
 
 	_ = dir

backend/mttnet/mttnet.go

@@ -140,7 +140,8 @@ func New(cfg config.P2P, db *sqlitex.Pool, blobs *hyper.Storage, me core.Identit
 	clean.Add(bitswap)
 
 	// TODO(burdiyan): find a better reproviding strategy than naive provide-everything.
-	providing, err := ipfs.NewProviderSystem(host.Datastore(), host.Routing, makeProvidingStrategy(db))
+
+	providing, err := ipfs.NewProviderSystem(host.Datastore(), host.Routing, makeProvidingStrategy(db, log.Level().String()))
 	if err != nil {
 		return nil, fmt.Errorf("failed to initialize providing: %w", err)
 	}

backend/mttnet/mttnet_test.go

@@ -61,7 +61,7 @@ func makeTestPeer(t *testing.T, name string) (*Node, context.CancelFunc) {
 	cfg.BootstrapPeers = nil
 	cfg.NoMetrics = true
 
-	n, err := New(cfg, db, blobs, u.Identity, must.Do2(zap.NewDevelopment()).Named(name))
+	n, err := New(cfg, db, blobs, u.Identity, must.Do2(zap.NewDevelopment()).Named(name), "debug")
 	require.NoError(t, err)
 
 	errc := make(chan error, 1)

backend/mttnet/providing.go

@@ -27,12 +27,12 @@ var qAllPublicBlobs = dqb.Str(`
 
 var randSrc = rand.NewSource(time.Now().UnixNano())
 
-func makeProvidingStrategy(db *sqlitex.Pool) provider.KeyChanFunc {
+func makeProvidingStrategy(db *sqlitex.Pool, logLevel string) provider.KeyChanFunc {
 	// This providing strategy returns all the CID known to the blockstore
 	// except those which are marked as draft changes.
 	// TODO(burdiyan): this is a temporary solution during the braking change.
 
-	log := logging.New("mintter/reprovider", "debug")
+	log := logging.New("mintter/reprovider", logLevel)
 
 	return func(ctx context.Context) (<-chan cid.Cid, error) {
 		ch := make(chan cid.Cid, 30) // arbitrary buffer
@@ -55,7 +55,7 @@ func makeProvidingStrategy(db *sqlitex.Pool) provider.KeyChanFunc {
 				log.Error("Failed to list entities", zap.Error(err))
 				return
 			}
-			log.Debug("Start reproviding", zap.Int("Number of entities", len(entities)))
+			log.Info("Start reproviding", zap.Int("Number of entities", len(entities)))
 			// Since reproviding takes long AND is has throttle limits, we are better off randomizing it.
 			r := rand.New(randSrc) //nolint:gosec
 			r.Shuffle(len(entities), func(i, j int) { entities[i], entities[j] = entities[j], entities[i] })
@@ -68,14 +68,14 @@ func makeProvidingStrategy(db *sqlitex.Pool) provider.KeyChanFunc {
 
 				select {
 				case <-ctx.Done():
-					log.Debug("Reproviding context cancelled")
+					log.Info("Reproviding context cancelled")
 					return
 				case ch <- c:
 					// Send
 					log.Debug("Reproviding", zap.String("entity", e.ResourcesIRI), zap.String("CID", c.String()))
 				}
 			}
-			log.Debug("Finish reproviding", zap.Int("Number of entities", len(entities)))
+			log.Info("Finish reproviding", zap.Int("Number of entities", len(entities)))
 		}()
 		return ch, nil
 	}

backend/syncing/syncing_test.go

@@ -103,7 +103,7 @@ func makeTestNode(t *testing.T, name string) testNode {
 	cfg.NoRelay = true
 	cfg.BootstrapPeers = nil
 	cfg.NoMetrics = true
-	n, err := mttnet.New(cfg, db, blobs, u.Identity, must.Do2(zap.NewDevelopment()).Named(name))
+	n, err := mttnet.New(cfg, db, blobs, u.Identity, must.Do2(zap.NewDevelopment()).Named(name), "debug")
 	require.NoError(t, err)
 
 	errc := make(chan error, 1)

backend/wallet/wallet_test.go

@@ -174,7 +174,7 @@ func makeTestPeer(t *testing.T, u coretest.Tester, db *sqlitex.Pool) (*mttnet.No
 		NoRelay:        true,
 		BootstrapPeers: nil,
 		NoMetrics:      true,
-	}, db, blobs, u.Identity, zap.NewNop())
+	}, db, blobs, u.Identity, zap.NewNop(), "debug")
 	require.NoError(t, err)
 
 	errc := make(chan error, 1)