go-common

README

Common Backend Framework

Welcome to the Common Backend Framework repository! This project provides a collection of utilities, libraries, and frameworks designed to standardize and streamline the development of backend API services within our organization.

• Gitbook: https://kittipat1413.gitbook.io/go-common
• Go Documentation: https://pkg.go.dev/github.com/kittipat1413/go-common
• Github Repo: https://github.com/kittipat1413/go-common

Introduction

This repository serves as a central codebase for common functionalities and utilities used across various backend API projects. By consolidating shared code, we aim to:

• Promote consistency and code standardization.
• Reduce duplication of effort.
• Facilitate easier maintenance and updates.
• Accelerate development by providing ready-to-use components.

Installation

Include the framework in your project by adding it to your go.mod file:

go get github.com/kittipat1413/go-common

Getting Started

1. Import the Framework

import (
    "github.com/kittipat1413/go-common/framework/logger"
    "github.com/kittipat1413/go-common/framework/trace"
    // ... other imports
)

1. Initialize Components Set up the components you need, such as the logger and tracer, in your application's entry point.

func main() {
    // Initialize the logger
    logger := logger.NewDefaultLogger()

    // Initialize the tracer
    endpoint := "localhost:4317"
    tracerProvider, err := trace.InitTracerProvider(ctx, "my-service", &endpoint, trace.ExporterGRPC)
    if err != nil {
      // Handle error
      return
    }
    defer func() {
      if err := tracerProvider.Shutdown(ctx); err != nil {
        // Handle error
      }
    }()

    // ... rest of your application setup
}

Example Project

Looking for a real-world implementation?

• Check out the 🎟️ Ticket Reservation System, a clean-architecture-based backend service that demonstrates how to integrate and use the go-common framework across all layers — config, logging, tracing, error handling, HTTP handlers, use cases, and repositories.

Modules and Packages

Logger

Provides a structured, context-aware logging interface using logrus. Designed for both development and production environments.

• Features:
  • Configurable log levels.
  • Structured logging with fields.
  • Context propagation for tracing (trace_id, span_id).
  • Flexible output destinations (stdout, files, etc.).
  • No-op logger for testing.

Tracer

Implements distributed tracing capabilities to monitor and debug microservices.

• Features:
  • Integrates with tracing systems like OpenTelemetry.
  • Captures spans and context propagation.
  • Minimal performance overhead.

Error

Standardizes error handling and response formatting.

• Features:
  • Consistent error formatting and wrapping.
  • Error codes and messages.
  • HTTP status code mapping.
  • Error response generation.

Event Package

Handles event-driven workflows, including message parsing and callback mechanisms.

• Features:
  • Integration with HTTP frameworks (like Gin).
  • Defining and processing event messages with flexible, user-defined payload types.
  • Generic payload support with Go generics.

Utilities

A collection of helper functions and common utilities.

• Features:
  • Date and time parsing.
  • String manipulation.
  • Configuration loading (e.g., from environment variables, config files).
  • etc.

License

This project is licensed under the MIT License.