refactor: major refactor which introduces new practices (#5)

[major] v1.0
1. Removed `vendor` directory for Go 
2. Introduced interface in API layer for different cmd implementations (server, subscriber, cli etc.)
3. Using OTEL for instrumentation
4. Upgraded all dependencies, including Go version
5. Updated docs to use gonew instead of custom bash script for reusing goapp to start a new project
6. Updated overall README to possibly make things easier to understand and clearer

.github/workflows/golangci-lint.yml

@@ -18,7 +18,7 @@ jobs:
     steps:
       - uses: actions/setup-go@v3
         with:
-          go-version: 1.18
+          go-version: 1.22
       - uses: actions/checkout@v3
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v3

.github/workflows/tests.yaml

@@ -9,15 +9,15 @@ on:
       - master
 jobs:
   test:
-    name: "Test with Go 1.19"
+    name: "Test with Go 1.22"
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
 
-      - name: Set up Go 1.19
+      - name: Set up Go 1.22
         uses: actions/setup-go@v3
         with:
-          go-version: 1.19
+          go-version: 1.22
 
       - name: Test
         run: go test -coverprofile=coverage.txt -covermode=atomic $(go list ./... | grep -v /cmd)

cmd/server/grpc/grpc.go

@@ -0,0 +1,13 @@
+package grpc
+
+import "github.com/bnkamalesh/goapp/internal/api"
+
+type GRPC struct {
+	apis api.Server
+}
+
+func New(apis api.Server) *GRPC {
+	return &GRPC{
+		apis: apis,
+	}
+}

internal/server/http/handlers.go → cmd/server/http/handlers.go

@@ -8,15 +8,15 @@ import (
 	"runtime/debug"
 
 	"github.com/bnkamalesh/errors"
-	"github.com/bnkamalesh/webgo/v6"
+	"github.com/bnkamalesh/webgo/v7"
 
 	"github.com/bnkamalesh/goapp/internal/api"
 	"github.com/bnkamalesh/goapp/internal/pkg/logger"
 )
 
 // Handlers struct has all the dependencies required for HTTP handlers
 type Handlers struct {
-	api  *api.API
+	apis api.Server
 	home *template.Template
 }
 
@@ -56,7 +56,7 @@ func (h *Handlers) routes() []*webgo.Route {
 // Health is the HTTP handler to return the status of the app including the version, and other details
 // This handler uses webgo to respond to the http request
 func (h *Handlers) Health(w http.ResponseWriter, r *http.Request) error {
-	out, err := h.api.Health()
+	out, err := h.apis.ServerHealth()
 	if err != nil {
 		return err
 	}
@@ -80,7 +80,7 @@ func (h *Handlers) HelloWorld(w http.ResponseWriter, r *http.Request) error {
 				struct {
 					Message string
 				}{
-					Message: "welcome to the home page!",
+					Message: "Welcome to the Home Page!",
 				},
 			)
 			if err != nil {
@@ -106,7 +106,9 @@ func errWrapper(h func(w http.ResponseWriter, r *http.Request) error) http.Handl
 
 		status, msg, _ := errors.HTTPStatusCodeMessage(err)
 		webgo.SendError(w, msg, status)
-		_ = logger.Error(errors.Stacktrace(err))
+		if status > 499 {
+			logger.Error(r.Context(), errors.Stacktrace(err))
+		}
 	}
 }
 
@@ -118,7 +120,7 @@ func panicRecoverer(w http.ResponseWriter, r *http.Request, next http.HandlerFun
 		}
 		webgo.R500(w, errors.DefaultMessage)
 
-		_ = logger.Error(fmt.Sprintf("%+v", p))
+		logger.Error(r.Context(), fmt.Sprintf("%+v", p))
 		fmt.Println(string(debug.Stack()))
 	}()
 

cmd/server/http/handlers_usernotes.go

@@ -0,0 +1,27 @@
+package http
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/bnkamalesh/errors"
+	"github.com/bnkamalesh/goapp/internal/usernotes"
+	"github.com/bnkamalesh/webgo/v7"
+)
+
+func (h *Handlers) CreateUserNote(w http.ResponseWriter, r *http.Request) error {
+	unote := new(usernotes.Note)
+	err := json.NewDecoder(r.Body).Decode(unote)
+	if err != nil {
+		return errors.InputBodyErr(err, "invalid JSON provided")
+	}
+
+	un, err := h.apis.CreateUserNote(r.Context(), unote)
+	if err != nil {
+		return err
+	}
+
+	webgo.R200(w, un)
+
+	return nil
+}

internal/server/http/handlers_users.go → cmd/server/http/handlers_users.go

@@ -5,7 +5,7 @@ import (
 	"net/http"
 
 	"github.com/bnkamalesh/errors"
-	"github.com/bnkamalesh/webgo/v6"
+	"github.com/bnkamalesh/webgo/v7"
 
 	"github.com/bnkamalesh/goapp/internal/users"
 )
@@ -19,21 +19,13 @@ func (h *Handlers) CreateUser(w http.ResponseWriter, r *http.Request) error {
 		return errors.InputBodyErr(err, "invalid JSON provided")
 	}
 
-	createdUser, err := h.api.CreateUser(r.Context(), u)
+	createdUser, err := h.apis.CreateUser(r.Context(), u)
 	if err != nil {
 		return err
 	}
 
-	b, err := json.Marshal(createdUser)
-	if err != nil {
-		return errors.InputBodyErr(err, "invalid input body provided")
-	}
+	webgo.R200(w, createdUser)
 
-	w.Header().Set("Content-Type", "application/json")
-	_, err = w.Write(b)
-	if err != nil {
-		return errors.Wrap(err, "failed to respond")
-	}
 	return nil
 }
 
@@ -42,11 +34,12 @@ func (h *Handlers) ReadUserByEmail(w http.ResponseWriter, r *http.Request) error
 	wctx := webgo.Context(r)
 	email := wctx.Params()["email"]
 
-	out, err := h.api.ReadUserByEmail(r.Context(), email)
+	out, err := h.apis.ReadUserByEmail(r.Context(), email)
 	if err != nil {
 		return err
 	}
 
 	webgo.R200(w, out)
+
 	return nil
 }

cmd/server/http/http.go

@@ -0,0 +1,106 @@
+package http
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/bnkamalesh/errors"
+	"github.com/bnkamalesh/goapp/internal/api"
+	"github.com/bnkamalesh/goapp/internal/pkg/apm"
+	"github.com/bnkamalesh/webgo/v7"
+	"github.com/bnkamalesh/webgo/v7/middleware/accesslog"
+	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
+)
+
+// Config holds all the configuration required to start the HTTP server
+type Config struct {
+	Host string
+	Port uint16
+
+	ReadTimeout  time.Duration
+	WriteTimeout time.Duration
+	DialTimeout  time.Duration
+
+	TemplatesBasePath string
+	EnableAccessLog   bool
+}
+
+type HTTP struct {
+	listener string
+	server   *webgo.Router
+}
+
+// Start starts the HTTP server
+func (h *HTTP) Start() error {
+	h.server.Start()
+	return nil
+}
+
+func (h *HTTP) Shutdown(ctx context.Context) error {
+	err := h.server.Shutdown()
+	if err != nil {
+		return errors.Wrap(err, "failed shutting down HTTP server")
+	}
+
+	return nil
+}
+
+// NewService returns an instance of HTTP with all its dependencies set
+func NewService(cfg *Config, apis api.Server) (*HTTP, error) {
+	home, err := loadHomeTemplate(cfg.TemplatesBasePath)
+	if err != nil {
+		return nil, err
+	}
+
+	handlers := &Handlers{
+		apis: apis,
+		home: home,
+	}
+
+	router := webgo.NewRouter(
+		&webgo.Config{
+			Host:            cfg.Host,
+			Port:            strconv.Itoa(int(cfg.Port)),
+			ReadTimeout:     cfg.ReadTimeout,
+			WriteTimeout:    cfg.WriteTimeout,
+			ShutdownTimeout: cfg.WriteTimeout * 2,
+		},
+		handlers.routes()...,
+	)
+
+	if cfg.EnableAccessLog {
+		router.Use(accesslog.AccessLog)
+		router.UseOnSpecialHandlers(accesslog.AccessLog)
+	}
+	router.Use(panicRecoverer)
+
+	otelopts := []otelhttp.Option{
+		// in this app, /-/ prefixed routes are used for healthchecks, readiness checks etc.
+		otelhttp.WithFilter(func(req *http.Request) bool {
+			return !strings.HasPrefix(req.URL.Path, "/-/")
+		}),
+		// the span name formatter is used to reduce the cardinality of metrics generated
+		// when using URIs with variables in it
+		otelhttp.WithSpanNameFormatter(func(operation string, r *http.Request) string {
+			wctx := webgo.Context(r)
+			if wctx == nil {
+				return r.URL.Path
+			}
+			return wctx.Route.Pattern
+		}),
+	}
+
+	apmMw := apm.NewHTTPMiddleware(otelopts...)
+	router.Use(func(w http.ResponseWriter, r *http.Request, hf http.HandlerFunc) {
+		apmMw(hf).ServeHTTP(w, r)
+	})
+
+	return &HTTP{
+		server:   router,
+		listener: fmt.Sprintf("%s:%d", cfg.Host, cfg.Port),
+	}, nil
+}

cmd/server/http/web/templates/index.html

@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Hello world</title>
+    <style>
+      html,
+      body {
+        font-size: 16px;
+        line-height: 1.5em;
+        min-width: 100vw;
+        min-height: 100vh;
+      }
+      body {
+        font-family: sans-serif;
+        background-color: #efefef;
+        color: #222;
+        height: 100vh;
+        width: 100vw;
+        overflow: hidden;
+      }
+      main {
+        margin: 40vh auto 0;
+        width: 35rem;
+      }
+      h1,
+      h2,
+      h3,
+      h4,
+      h5,
+      h6 {
+        font-family: "Roboto", sans-serif;
+        font-weight: 400;
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h3 id="colorize" style="text-align: center">{{.Message}}</h3>
+    </main>
+  </body>
+</html>

cmd/subscribers/kafka/kafka.go

@@ -0,0 +1,14 @@
+// Package kafka implements the Kafka subscription functionality
+package kafka
+
+import "github.com/bnkamalesh/goapp/internal/api"
+
+type Kafka struct {
+	apis api.Subscriber
+}
+
+func New(apis api.Subscriber) *Kafka {
+	return &Kafka{
+		apis: apis,
+	}
+}

docker/Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.20 AS builder
+FROM golang:1.22 AS builder
 
 COPY ../ /app
 WORKDIR /app
@@ -13,10 +13,10 @@ LABEL MAINTAINER Author <[email protected]>
 
 # Following commands are for installing CA certs (for proper functioning of HTTPS and other TLS)
 RUN apt-get update && apt-get install -y --no-install-recommends \
-		ca-certificates  \
-        netbase \
-        && rm -rf /var/lib/apt/lists/ \
-        && apt-get autoremove -y && apt-get autoclean -y
+    ca-certificates  \
+    netbase \
+    && rm -rf /var/lib/apt/lists/ \
+    && apt-get autoremove -y && apt-get autoclean -y
 
 # Add new user 'appuser'. App should be run without root privileges as a security measure
 RUN adduser --home "/appuser" --disabled-password appuser \

docker/docker-compose.yml

@@ -1,26 +1,35 @@
 version: "3.9"
 services:
   redis:
-    image: "redis:alpine"
+    image: "redis:7"
     networks:
       - goapp_network
 
   postgres:
-    image: "postgres"
+    image: "postgres:16"
     environment:
       POSTGRES_PASSWORD: gauserpassword
       POSTGRES_USER: gauser
       POSTGRES_DB: goapp
+    ports:
+      - "5432:5432"
     networks:
       - goapp_network
 
   goapp:
-    image: golang:1.20
+    image: golang:1.22
     volumes:
       - ${PWD}:/app
     working_dir: /app
-    # command: go run main.go
     tty: true
+    environment:
+      TEMPLATES_BASEPATH: /app/cmd/server/http/web/templates
+      POSTGRES_HOST: postgres
+      POSTGRES_PORT: 5432
+      POSTGRES_STORENAME: "goapp"
+      POSTGRES_USERNAME: "gauser"
+      POSTGRES_PASSWORD: "gauserpassword"
+    command: go run main.go
     ports:
       - "8080:8080"
     depends_on: