Merge pull request #28 from github/vdye/initial-trace2

Logging Part 1: initial `trace2` events (`start`, `cmd_name`, `error`, `exit`, `atexit`)

Author: vdye

cmd/git-bundle-server/delete.go

@@ -1,47 +1,57 @@
 package main
 
 import (
+	"context"
 	"os"
 
 	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/core"
+	"github.com/github/git-bundle-server/internal/log"
 )
 
-type Delete struct{}
+type deleteCmd struct {
+	logger log.TraceLogger
+}
+
+func NewDeleteCommand(logger log.TraceLogger) argparse.Subcommand {
+	return &deleteCmd{
+		logger: logger,
+	}
+}
 
-func (Delete) Name() string {
+func (deleteCmd) Name() string {
 	return "delete"
 }
 
-func (Delete) Description() string {
+func (deleteCmd) Description() string {
 	return `
 Remove the configuration for the given '<route>' and delete its repository
 data.`
 }
 
-func (Delete) Run(args []string) error {
-	parser := argparse.NewArgParser("git-bundle-server delete <route>")
+func (d *deleteCmd) Run(ctx context.Context, args []string) error {
+	parser := argparse.NewArgParser(d.logger, "git-bundle-server delete <route>")
 	route := parser.PositionalString("route", "the route to delete")
-	parser.Parse(args)
+	parser.Parse(ctx, args)
 
 	repo, err := core.CreateRepository(*route)
 	if err != nil {
-		return err
+		return d.logger.Error(ctx, err)
 	}
 
 	err = core.RemoveRoute(*route)
 	if err != nil {
-		return err
+		return d.logger.Error(ctx, err)
 	}
 
 	err = os.RemoveAll(repo.WebDir)
 	if err != nil {
-		return err
+		return d.logger.Error(ctx, err)
 	}
 
 	err = os.RemoveAll(repo.RepoDir)
 	if err != nil {
-		return err
+		return d.logger.Error(ctx, err)
 	}
 
 	return nil

cmd/git-bundle-server/init.go

@@ -1,70 +1,80 @@
 package main
 
 import (
+	"context"
 	"fmt"
 
 	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/bundles"
 	"github.com/github/git-bundle-server/internal/core"
 	"github.com/github/git-bundle-server/internal/git"
+	"github.com/github/git-bundle-server/internal/log"
 )
 
-type Init struct{}
+type initCmd struct {
+	logger log.TraceLogger
+}
+
+func NewInitCommand(logger log.TraceLogger) argparse.Subcommand {
+	return &initCmd{
+		logger: logger,
+	}
+}
 
-func (Init) Name() string {
+func (initCmd) Name() string {
 	return "init"
 }
 
-func (Init) Description() string {
+func (initCmd) Description() string {
 	return `
 Initialize a repository by cloning a bare repo from '<url>', whose bundles
 should be hosted at '<route>'.`
 }
 
-func (Init) Run(args []string) error {
-	parser := argparse.NewArgParser("git-bundle-server init <url> <route>")
+func (i *initCmd) Run(ctx context.Context, args []string) error {
+	parser := argparse.NewArgParser(i.logger, "git-bundle-server init <url> <route>")
 	url := parser.PositionalString("url", "the URL of a repository to clone")
 	// TODO: allow parsing <route> out of <url>
 	route := parser.PositionalString("route", "the route to host the specified repo")
-	parser.Parse(args)
+	parser.Parse(ctx, args)
 
 	repo, err := core.CreateRepository(*route)
 	if err != nil {
-		return err
+		return i.logger.Error(ctx, err)
 	}
 
 	fmt.Printf("Cloning repository from %s\n", *url)
 	gitErr := git.GitCommand("clone", "--bare", *url, repo.RepoDir)
 
 	if gitErr != nil {
-		return fmt.Errorf("failed to clone repository: %w", gitErr)
+		return i.logger.Errorf(ctx, "failed to clone repository: %w", gitErr)
 	}
 
 	gitErr = git.GitCommand("-C", repo.RepoDir, "config", "remote.origin.fetch", "+refs/heads/*:refs/heads/*")
 	if gitErr != nil {
-		return fmt.Errorf("failed to configure refspec: %w", gitErr)
+		return i.logger.Errorf(ctx, "failed to configure refspec: %w", gitErr)
 	}
 
 	gitErr = git.GitCommand("-C", repo.RepoDir, "fetch", "origin")
 	if gitErr != nil {
-		return fmt.Errorf("failed to fetch latest refs: %w", gitErr)
+		return i.logger.Errorf(ctx, "failed to fetch latest refs: %w", gitErr)
 	}
 
 	bundle := bundles.CreateInitialBundle(repo)
 	fmt.Printf("Constructing base bundle file at %s\n", bundle.Filename)
 
 	written, gitErr := git.CreateBundle(repo.RepoDir, bundle.Filename)
 	if gitErr != nil {
-		return fmt.Errorf("failed to create bundle: %w", gitErr)
+		return i.logger.Errorf(ctx, "failed to create bundle: %w", gitErr)
 	}
 	if !written {
-		return fmt.Errorf("refused to write empty bundle. Is the repo empty?")
+		return i.logger.Errorf(ctx, "refused to write empty bundle. Is the repo empty?")
 	}
 
 	list := bundles.CreateSingletonList(bundle)
 	listErr := bundles.WriteBundleList(list, repo)
 	if listErr != nil {
-		return fmt.Errorf("failed to write bundle list: %w", listErr)
+		return i.logger.Errorf(ctx, "failed to write bundle list: %w", listErr)
 	}
 
 	SetCronSchedule()

cmd/git-bundle-server/main.go

@@ -1,36 +1,39 @@
 package main
 
 import (
-	"log"
+	"context"
 	"os"
 
 	"github.com/github/git-bundle-server/internal/argparse"
+	"github.com/github/git-bundle-server/internal/log"
 )
 
-func all() []argparse.Subcommand {
+func all(logger log.TraceLogger) []argparse.Subcommand {
 	return []argparse.Subcommand{
-		Delete{},
-		Init{},
-		Start{},
-		Stop{},
-		Update{},
-		UpdateAll{},
-		NewWebServerCommand(),
+		NewDeleteCommand(logger),
+		NewInitCommand(logger),
+		NewStartCommand(logger),
+		NewStopCommand(logger),
+		NewUpdateCommand(logger),
+		NewUpdateAllCommand(logger),
+		NewWebServerCommand(logger),
 	}
 }
 
 func main() {
-	cmds := all()
+	log.WithTraceLogger(context.Background(), func(ctx context.Context, logger log.TraceLogger) {
+		cmds := all(logger)
 
-	parser := argparse.NewArgParser("git-bundle-server <command> [<options>]")
-	parser.SetIsTopLevel(true)
-	for _, cmd := range cmds {
-		parser.Subcommand(cmd)
-	}
-	parser.Parse(os.Args[1:])
+		parser := argparse.NewArgParser(logger, "git-bundle-server <command> [<options>]")
+		parser.SetIsTopLevel(true)
+		for _, cmd := range cmds {
+			parser.Subcommand(cmd)
+		}
+		parser.Parse(ctx, os.Args[1:])
 
-	err := parser.InvokeSubcommand()
-	if err != nil {
-		log.Fatal("Failed with error: ", err)
-	}
+		err := parser.InvokeSubcommand(ctx)
+		if err != nil {
+			logger.Fatalf(ctx, "Failed with error: %s", err)
+		}
+	})
 }

cmd/git-bundle-server/start.go

@@ -1,39 +1,48 @@
 package main
 
 import (
-	"fmt"
+	"context"
 	"os"
 
 	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/core"
+	"github.com/github/git-bundle-server/internal/log"
 )
 
-type Start struct{}
+type startCmd struct {
+	logger log.TraceLogger
+}
+
+func NewStartCommand(logger log.TraceLogger) argparse.Subcommand {
+	return &startCmd{
+		logger: logger,
+	}
+}
 
-func (Start) Name() string {
+func (startCmd) Name() string {
 	return "start"
 }
 
-func (Start) Description() string {
+func (startCmd) Description() string {
 	return `
 Start computing bundles and serving content for the repository at the
 specified '<route>'.`
 }
 
-func (Start) Run(args []string) error {
-	parser := argparse.NewArgParser("git-bundle-server start <route>")
+func (s *startCmd) Run(ctx context.Context, args []string) error {
+	parser := argparse.NewArgParser(s.logger, "git-bundle-server start <route>")
 	route := parser.PositionalString("route", "the route for which bundles should be generated")
-	parser.Parse(args)
+	parser.Parse(ctx, args)
 
 	// CreateRepository registers the route.
 	repo, err := core.CreateRepository(*route)
 	if err != nil {
-		return err
+		return s.logger.Error(ctx, err)
 	}
 
 	_, err = os.ReadDir(repo.RepoDir)
 	if err != nil {
-		return fmt.Errorf("route '%s' appears to have been deleted; use 'init' instead", *route)
+		return s.logger.Errorf(ctx, "route '%s' appears to have been deleted; use 'init' instead", *route)
 	}
 
 	// Make sure we have the global schedule running.

cmd/git-bundle-server/stop.go

@@ -1,26 +1,42 @@
 package main
 
 import (
+	"context"
+
 	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/core"
+	"github.com/github/git-bundle-server/internal/log"
 )
 
-type Stop struct{}
+type stopCmd struct {
+	logger log.TraceLogger
+}
 
-func (Stop) Name() string {
+func NewStopCommand(logger log.TraceLogger) argparse.Subcommand {
+	return &stopCmd{
+		logger: logger,
+	}
+}
+
+func (stopCmd) Name() string {
 	return "stop"
 }
 
-func (Stop) Description() string {
+func (stopCmd) Description() string {
 	return `
 Stop computing bundles or serving content for the repository at the
 specified '<route>'.`
 }
 
-func (Stop) Run(args []string) error {
-	parser := argparse.NewArgParser("git-bundle-server stop <route>")
+func (s *stopCmd) Run(ctx context.Context, args []string) error {
+	parser := argparse.NewArgParser(s.logger, "git-bundle-server stop <route>")
 	route := parser.PositionalString("route", "the route for which bundles should stop being generated")
-	parser.Parse(args)
+	parser.Parse(ctx, args)
+
+	err := core.RemoveRoute(*route)
+	if err != nil {
+		s.logger.Error(ctx, err)
+	}
 
-	return core.RemoveRoute(*route)
+	return nil
 }