feature: cli-based implementation for viewing statistics

Author: omarabdelaz1z

cmd/statistics/helper.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/manifoldco/promptui"
+)
+
+var monthNames map[string]string = map[string]string{
+	"01": "January",
+	"02": "February",
+	"03": "March",
+	"04": "April",
+	"05": "May",
+	"06": "June",
+	"07": "July",
+	"08": "August",
+	"09": "September",
+	"10": "October",
+	"11": "November",
+	"12": "December",
+}
+
+func transformMonthName(months ...string) []string {
+	var names []string
+
+	for _, month := range months {
+		names = append(names, fmt.Sprintf("%s - %s", month, monthNames[month]))
+	}
+
+	return names
+}
+
+func selectPrompt(label string, items ...string) (int, string, error) {
+	ps := promptui.Select{
+		Label: label,
+		Items: items,
+	}
+
+	index, result, err := ps.Run()
+
+	if err != nil {
+		if err == promptui.ErrInterrupt {
+			return -1, "", nil
+		}
+
+		return -1, "", fmt.Errorf("failed to run prompt: %w", err)
+	}
+
+	return index, result, nil
+}

cmd/statistics/main.go

@@ -0,0 +1,89 @@
+package main
+
+import (
+	"database/sql"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/omarabdelaz1z/go-monitor/cmd/config"
+	"github.com/omarabdelaz1z/go-monitor/cmd/helper"
+
+	"github.com/omarabdelaz1z/go-monitor/cmd/provider"
+	"github.com/omarabdelaz1z/go-monitor/internal/model"
+	"github.com/rs/zerolog"
+)
+
+func main() {
+	var (
+		db   *sql.DB
+		err  error
+		file *os.File
+		cfg  *config.Config = &config.Config{}
+	)
+
+	flag.StringVar(&cfg.Db.Driver, "driver", os.Getenv("DB_DRIVER"), "database driver")
+	flag.StringVar(&cfg.Db.Dsn, "dsn", os.Getenv("DB_DSN"), "database dsn")
+	flag.IntVar(&cfg.Db.MaxIdleConns, "max-idle-conns", 5, "max idle connections")
+	flag.IntVar(&cfg.Db.MaxOpenConns, "max-open-conns", 10, "max open connections")
+	flag.IntVar(&cfg.Db.MaxIdleTime, "max-idle-time", 2, "max idle time")
+
+	flag.StringVar(&cfg.Log.Path, "log-path", os.Getenv("LOG_PATH"), "log path")
+
+	helper.EnumFlag(&cfg.Log.Level, "log-level", []string{"debug", "info", "warn", "error"}, "log level")
+	flag.Parse()
+
+	logLevel := zerolog.Level(helper.GetLevel(cfg.Log.Level))
+
+	file, err = os.OpenFile(cfg.Log.Path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+
+	if err != nil {
+		panic(err)
+	}
+
+	logger := zerolog.New(zerolog.MultiLevelWriter(file, zerolog.ConsoleWriter{
+		Out:        os.Stdout,
+		TimeFormat: time.RFC1123,
+		FormatCaller: func(i interface{}) string {
+			if i == nil {
+				return ""
+			}
+			return filepath.Base(fmt.Sprintf("%+v", i))
+		},
+	})).Level(logLevel).With().Timestamp().Logger()
+
+	logger.Debug().Msg("initiating connection to database")
+
+	db, err = provider.NewDatabase(&provider.DbConfig{
+		Driver:       cfg.Db.Driver,
+		Dsn:          cfg.Db.Dsn,
+		MaxIdleConns: cfg.Db.MaxIdleConns,
+		MaxOpenConns: cfg.Db.MaxOpenConns,
+		MaxIdleTime:  cfg.Db.MaxIdleTime,
+	})
+
+	if err != nil {
+		logger.Fatal().Err(err).Msg("failed to initiate connection to database")
+		return
+	}
+
+	logger.Info().Msg("connected to database")
+
+	defer db.Close()
+
+	service := &Service{
+		snapshots:     model.NewSnapshotModel(db),
+		config:        cfg,
+		logger:        logger,
+		monthSafeList: []string{},
+	}
+
+	if err = service.Run(); err != nil {
+		logger.Fatal().Err(err).Msg("error occrred while running service")
+		return
+	}
+
+	logger.Info().Msg("service stopped successfully")
+}

cmd/statistics/service.go

@@ -0,0 +1,203 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/omarabdelaz1z/go-monitor/cmd/config"
+	"github.com/omarabdelaz1z/go-monitor/internal/model"
+	"github.com/omarabdelaz1z/go-monitor/internal/util"
+
+	"github.com/rs/zerolog"
+	"golang.org/x/sync/errgroup"
+)
+
+type Service struct {
+	snapshots *model.SnapshotModel
+	config    *config.Config
+	logger    zerolog.Logger
+
+	monthSafeList []string
+}
+
+func (s *Service) Run() error {
+	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
+	defer stop()
+
+	g, gCtx := errgroup.WithContext(ctx)
+
+	months, err := s.snapshots.GetMonthsInYear(gCtx, fmt.Sprint(time.Now().Year()))
+
+	if err != nil {
+		return fmt.Errorf("failed to get months: %w", err)
+	}
+
+	s.monthSafeList = transformMonthName(months...)
+
+	g.Go(func() error {
+		return s.Respond(gCtx)
+	})
+
+	if err = g.Wait(); err != nil {
+		s.logger.Error().Err(err).Caller().Msg("service failed while running")
+		return fmt.Errorf("service failed while running: %w", err)
+	}
+
+	return nil
+}
+
+func (s *Service) Respond(ctx context.Context) error {
+	t := table.NewWriter()
+	t.SetOutputMirror(os.Stdout)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		default:
+			option, _, err := selectPrompt("What would you like to do?", "View today's stats", "View stats for a month", "View all stats", "Exit")
+
+			if option == -1 && nil == err {
+				return nil
+			}
+
+			if err != nil {
+				return err
+			}
+
+			switch option {
+			case 0:
+				err = s.HandleTodayStats(ctx, t)
+
+				if err != nil {
+					switch err {
+					case model.ErrNoRows:
+						fmt.Println("No stats for today")
+					case model.ErrTimedOut:
+						fmt.Println("Timed out while fetching stats")
+					default:
+						return err
+					}
+				}
+
+				t.Render()
+			case 1:
+				err = s.HandleMonthStats(ctx, t)
+
+				if err != nil {
+					return err
+				}
+
+				t.Render()
+			case 2:
+				err = s.HandleAllStats(ctx, t)
+
+				if err != nil {
+					return err
+				}
+
+				t.Render()
+			case 3:
+				return nil
+			}
+
+			t.ResetHeaders()
+			t.ResetRows()
+			t.ResetFooters()
+		}
+	}
+}
+
+func (s *Service) HandleMonthStats(ctx context.Context, t table.Writer) error {
+	var (
+		err        error
+		option     string
+		dailyStats []model.Snapshot
+	)
+
+	_, option, err = selectPrompt("Which month would you like to view?", s.monthSafeList...)
+
+	if err != nil {
+		return err
+	}
+
+	if nil == err && option == "" {
+		return nil
+	}
+
+	dailyStats, err = s.snapshots.GetStatsByMonth(ctx, option[:2])
+
+	if err != nil {
+		return fmt.Errorf("failed to get stats by month: %w", err)
+	}
+
+	t.SetCaption(fmt.Sprintf("Stats for %s", option[5:]))
+	t.AppendHeader(table.Row{"Date", "Uploaded", "Downloaded", "Total"})
+
+	for i := 0; i < len(dailyStats)-1; i++ {
+		t.AppendRow(table.Row{
+			time.Unix(dailyStats[i].Timestamp, 0).Format("2006-01-02"),
+			util.ByteCountSI(dailyStats[i].Stat.Sent),
+			util.ByteCountSI(dailyStats[i].Stat.Received),
+			util.ByteCountSI(dailyStats[i].Stat.Total),
+		})
+	}
+
+	t.AppendSeparator()
+	t.AppendFooter(table.Row{
+		"Cumulative",
+		util.ByteCountSI(dailyStats[len(dailyStats)-1].Stat.Sent),
+		util.ByteCountSI(dailyStats[len(dailyStats)-1].Stat.Received),
+		util.ByteCountSI(dailyStats[len(dailyStats)-1].Stat.Total),
+	})
+
+	return nil
+}
+
+func (s *Service) HandleAllStats(ctx context.Context, t table.Writer) error {
+	stats, err := s.snapshots.GetAllStats(ctx)
+
+	if err != nil {
+		return fmt.Errorf("failed to get stats: %w", err)
+	}
+
+	t.SetCaption("All stats")
+	t.AppendHeader(table.Row{"Month", "Uploaded", "Downloaded", "Total"})
+
+	for _, stat := range stats {
+		t.AppendRow(table.Row{
+			time.Unix(stat.Timestamp, 0).Format("2006-01-02"),
+			util.ByteCountSI(stat.Stat.Sent),
+			util.ByteCountSI(stat.Stat.Received),
+			util.ByteCountSI(stat.Stat.Total),
+		})
+	}
+
+	return nil
+}
+
+func (s *Service) HandleTodayStats(ctx context.Context, t table.Writer) error {
+	today := time.Now().Format("2006-01-02")
+
+	stat, err := s.snapshots.GetStatByDate(ctx, today)
+
+	if err != nil {
+		return err
+	}
+
+	t.SetCaption(fmt.Sprintf("Monitored %d hours on %s", stat.HoursMonitored, today))
+	t.AppendHeader(table.Row{"Uploaded", "Downloaded", "Total"})
+
+	t.AppendRow(table.Row{
+		util.ByteCountSI(stat.Stat.Sent),
+		util.ByteCountSI(stat.Stat.Received),
+		util.ByteCountSI(stat.Stat.Total),
+	})
+
+	return nil
+}