refactor: change system logging

.gitignore

@@ -1,2 +1,2 @@
 .env
-agent.dev.yaml
+config.yaml

agent/cmd/main.go

@@ -7,7 +7,7 @@ import (
 func main() {
 	start, err := app.NewApp()
 	if err != nil {
-		return
+		panic(err)
 	}
 	start.Run()
 }

agent/internal/app/app.go

@@ -11,7 +11,7 @@ import (
 	"github.com/lorsanstand/HomeOps-Hub/agent/internal/service/docker_service"
 	"github.com/lorsanstand/HomeOps-Hub/agent/internal/utils/config_yaml"
 	"github.com/lorsanstand/HomeOps-Hub/agent/internal/utils/settings"
-	log2 "github.com/lorsanstand/HomeOps-Hub/shared/log"
+	"github.com/lorsanstand/HomeOps-Hub/shared/log"
 	"github.com/rs/zerolog"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
@@ -31,16 +31,16 @@ func NewApp() (*App, error) {
 		return nil, err
 	}
 
-	log := log2.NewLogger(cfg)
+	logger := log.NewLogger(cfg)
-	log = log.With().Str("component", "agent.app").Logger()
+	logger = logger.With().Str("component", "internal.app").Logger()
 
 	sett, err := settings.ReadSettings(cfg.SettingsPath)
 	if err != nil {
-		log.Error().Err(err).Msg("failed to get settings")
+		logger.Error().Err(err).Msg("failed to get settings")
 		return nil, err
 	}
 
-	return &App{cfg: cfg, log: log, settings: sett}, nil
+	return &App{cfg: cfg, log: logger, settings: sett}, nil
 }
 
 func (a *App) Run() {
@@ -48,11 +48,12 @@ func (a *App) Run() {
 
 	GRPCConn, err := grpc.NewClient(a.cfg.GetGRPCAddress(), grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
-		a.log.Error().Err(err).Msg("failed to get agent connections")
+		a.log.Error().Err(err).Msg("failed to connection hub")
 		return
 	}
+	a.log.Info().Msg("connection to the hub successful")
 
-	conn := rpc.NewConnectAgent(GRPCConn, a.log)
+	conn := rpc.NewConnectAgent(GRPCConn)
 	defer conn.Close()
 
 	var DockerService collector.Docker
@@ -62,11 +63,15 @@ func (a *App) Run() {
 		a.log.Warn().Err(err).Msg("failed to get docker API")
 		DockerService = docker_service.NewBadDocker("not_installed")
 	} else {
+		a.log.Info().Msg("successfully to get docker API")
 		DockerService = docker_service.NewDockerService(DockerClient, a.log)
 	}
 
 	collect := collector.NewCollector(DockerService, a.log)
 
 	agent := agent_service.NewAgentService(collect, conn, a.settings, a.cfg, a.log)
-	agent.RegisterAgentConn(ctx)
+	if err := agent.RegisterAgentConn(ctx); err != nil {
+		a.log.Error().Err(err).Msg("failed to agent registration")
+	}
+	a.log.Info().Msg("agent registration complete")
 }

agent/internal/rpc/client.go

@@ -5,26 +5,20 @@ import (
 
 	pb "github.com/lorsanstand/HomeOps-Hub/api/gen/homeops"
 	"github.com/lorsanstand/HomeOps-Hub/shared/domain"
-	"github.com/rs/zerolog"
 	"google.golang.org/grpc"
 )
 
 type Connection struct {
 	hub  pb.HubClient
 	conn *grpc.ClientConn
-	log  zerolog.Logger
 }
 
-func NewConnectAgent(conn *grpc.ClientConn, logger zerolog.Logger) *Connection {
+func NewConnectAgent(conn *grpc.ClientConn) *Connection {
-	logger = logger.With().Str("component", "agent.rpc").Logger()
-
 	client := pb.NewHubClient(conn)
-
+	return &Connection{hub: client, conn: conn}
-	return &Connection{hub: client, conn: conn, log: logger}
 }
 
 func (c *Connection) Close() error {
-	c.log.Warn().Msg("connection close")
 	return c.conn.Close()
 }
 
@@ -34,6 +28,5 @@ func (c *Connection) Hub() pb.HubClient {
 
 func (c *Connection) RegisterAgent(ctx context.Context, RegisterData domain.RegisterAgentRequest) (domain.RegisterAgentResponse, error) {
 	ResponseData, err := c.Hub().RegisterAgent(ctx, new(domain.ToGRPCAgentRequest(RegisterData)))
-	c.log.Info().Msg("register agent")
 	return domain.ToDomainAgentResponse(ResponseData), err
 }

agent/internal/service/agent_service/agent.go

@@ -10,8 +10,6 @@ import (
 	"github.com/rs/zerolog"
 )
 
-const AgentVersion = "0.0"
-
 type Collector interface {
 	GatherInfoSystem() (domain.HostInfo, []domain.Capability)
 }
@@ -36,25 +34,33 @@ func NewAgentService(
 	cfg *config_yaml.AgentConfig,
 	logger zerolog.Logger,
 ) *AgentService {
-	logger = logger.With().Str("component", "cmd.service.agent_serivce").Logger()
+	logger = logger.With().Str("component", "internal.service.agent_serivce").Logger()
 
 	return &AgentService{collect: collector, conn: conn, cfg: cfg, log: logger, settings: settings}
 }
 
-func (a *AgentService) RegisterAgentConn(ctx context.Context) {
+func (a *AgentService) RegisterAgentConn(ctx context.Context) error {
+	a.log.Debug().Msg("getting info by system")
 	info, caps := a.collect.GatherInfoSystem()
+	a.log.Debug().Msg("create request data for register agent")
 	AgentID := a.settings.AgentID
 	AgentName := a.cfg.AppName
-	AgentData := domain.RegisterAgentRequest{AgentId: AgentID, AgentName: AgentName, Host: info, Capabilities: caps, AgentVersion: AgentVersion}
+	AgentData := domain.RegisterAgentRequest{
+		AgentId:      AgentID,
+		AgentName:    AgentName,
+		Host:         info,
+		Capabilities: caps,
+		AgentVersion: a.cfg.GetAgentVersion(),
+	}
 
 	data, err := a.conn.RegisterAgent(ctx, AgentData)
 	if err != nil {
-		a.log.Error().Err(err).Msg("failed register cmd")
+		return fmt.Errorf("register agent: %w", err)
-		return
 	}
 
 	if err = a.settings.Insert(settings.Settings{AgentID: data.AgentID}); err != nil {
-		a.log.Warn().Err(err).Msg("failed to save cmd id")
+		return fmt.Errorf("save agent ID: %w", err)
 	}
-	fmt.Println(data)
+
+	return nil
 }

agent/internal/service/collector/collector.go

@@ -18,7 +18,7 @@ type Collector struct {
 }
 
 func NewCollector(docker Docker, logger zerolog.Logger) *Collector {
-	logger = logger.With().Str("component", "cmd.service.collector").Logger()
+	logger = logger.With().Str("component", "internal.service.collector").Logger()
 
 	return &Collector{log: logger, dockerReader: docker}
 }

agent/internal/service/docker_service/docker.go

@@ -23,13 +23,13 @@ type DockerService struct {
 func NewDockerService(api dockerAPI, logger zerolog.Logger) *DockerService {
 	return &DockerService{
 		dockerClient: api,
-		log:          logger.With().Str("component", "cmd.serivce.docker").Logger(),
+		log:          logger.With().Str("component", "internal.serivce.docker").Logger(),
 	}
 }
 
 func (d *DockerService) CheckDockerDaemon(ctx context.Context) error {
 	_, err := d.dockerClient.Ping(ctx)
-	d.log.Debug().Msg("check docker")
+	d.log.Debug().Msg("ping docker")
 	return err
 }
 

agent/internal/utils/config_yaml/config.go

@@ -8,6 +8,9 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
+const MODE = "DEV"
+const AgentVersion = "0.0"
+
 type AgentConfig struct {
 	AppName    string `yaml:"app_name"`
 	HubConnect struct {
@@ -19,7 +22,7 @@ type AgentConfig struct {
 }
 
 func NewConfig() (*AgentConfig, error) {
-	yamlFile, err := os.ReadFile("agent.dev.yaml")
+	yamlFile, err := os.ReadFile("config.yaml")
 	if err != nil {
 		return nil, fmt.Errorf("failed open file: %v", err)
 	}
@@ -42,7 +45,11 @@ func (c *AgentConfig) GetLogLevel() zerolog.Level {
 }
 
 func (c *AgentConfig) GetMode() string {
-	return "DEV"
+	return MODE
+}
+
+func (c *AgentConfig) GetAgentVersion() string {
+	return AgentVersion
 }
 
 func (c *AgentConfig) GetGRPCAddress() string {