glog and gcolor in quick

[jeffotoni]

🎨 gcolor – Fluent ANSI Color Library in Go

We created a library called gcolor, with a fluent, modern and flexible API for styling terminal output in Go using ANSI escape codes.

Inspired by libraries like fatih/color, gookit/color and termenv, it allows you to compose styles elegantly with support for:

✅ Foreground and background colors
✅ Styles like Bold() and Underline()
✅ Fluent chaining (.Fg().Bg().Bold().Println())
✅ Sprint, Sprintf, Print, Println
✅ Integration with log.SetPrefix, log.Printf, etc.
✅ 100% test coverage with go test
✅ Examples documented in the official Go style

Example Full

import (
    "fmt"
    "log"
    "time"

    "github.com/jeffotoni/quick/pkg/gcolor"
)

func main() {
    // Simples com foreground
    gcolor.New().Fg("green").Println("Success message")

    // Foreground + background
    gcolor.New().Fg("white").Bg("red").Println("Error with red background")

    // Bold
    gcolor.New().Fg("yellow").Bold().Println("Warning in bold")

    // Underline
    gcolor.New().Fg("cyan").Underline().Println("Link or reference")

    // Estilo encadeado completo
    gcolor.New().
        Fg("blue").
        Bg("white").
        Bold().
        Underline().
        Println("Styled and readable message")

    // Formatação com Sprintf
    user := "jeffotoni"
    fmt.Println(gcolor.New().Fg("green").Sprintf("Welcome, %s!", user))

    // Log formatado com partes coloridas
    traceID := "abc123"
    duration := 215 * time.Millisecond
    log.Printf(
        "[Trace-ID: %s] <- Completed in %s\n",
        gcolor.New().Fg("cyan").Sprint(traceID),
        gcolor.New().Fg("yellow").Sprintf("%v", duration),
    )

    // Reuso de estilos
    warnStyle := gcolor.New().Fg("yellow").Bold()
    warnStyle.Println("Disk space running low...")

    infoStyle := gcolor.New().Fg("blue")
    infoStyle.Println("Server started successfully")

    // Prefixo colorido no log
    log.SetPrefix(gcolor.New().Fg("purple").Sprint("[GCOLOR] "))
    log.Println("Logger initialized")
}

🚀 Project glog – Modern and lightweight logger in Go

We have just created glog, a flexible, lightweight and powerful logging library for Go, inspired by modern best practices and the simplicity that every project needs.

✅ Features:

  •3 output formats:
  •text: terminal style, colored fields (value field)
  •slog: structured field=value style, with color
  •json: structured for machines, without color
  •Dynamic and customizable pattern
  •Use ${time} ${level} ${msg} or any composition you want
  •Fields not present in the pattern are automatically added, with the inferred separator
  •Smart separator
  •Automatically detected based on your Pattern (" ", " | ", etc.)
  •Log levels: DEBUG, INFO, WARN, ERROR
  •Support for Fields (dynamic field map) per call
  •Global fields (CustomFields) that appear in all logs
  •Functions with formatting: Debugf, Infof, Warnf, Errorf
  •File and line inclusion (file:line) with IncludeCaller: true
  •Colors for highlighting in the terminal (only in the level field, by default)
  •100% tested, including:
  •Coverage of all formats
  •Automatic separator
  •Dynamic fields
  •Inclusion of line of code
  •Defaults applied correctly

glog.Set(glog.Config{
          Format: "text",
          Level: glog.DEBUG,
          IncludeCaller: true,
          Pattern: "[${time}] ${level} ${msg} ",
          CustomFields: map[string]string{
               "service": "example-api",
          },
})

glog.Info("User login", glog.Fields{"user": "jeff"})

[2025-03-29 17:01:00] INFO User login file.go:42 user jeff service example-api

Example full

package main

import (
	"github.com/jeffotoni/quick/pkg/gcolor"
	"github.com/jeffotoni/quick/pkg/glog"
	"github.com/jeffotoni/quick/pkg/rand"
)

func main() {
	// Configure glog with slog-style output (field=value), custom timestamp and default level
	glog.Set(glog.Config{
		Format:     "text",                // Use slog formatting (key=value, colored)
		TimeFormat: "2006-01-02 15:04:05", // Human-friendly timestamp format
		Level:      glog.DEBUG,            // Minimum log level to display
		CustomFields: map[string]string{ // Fields injected into every log entry
			"service": "example-api",
			"env":     "production",
		},
		IncludeCaller: true,
		// Optional: use a custom pattern if desired
		// Pattern: "[${time}] ${level} ${msg}",
		// Pattern: "${time} ${level} ${msg} user=${user} retry=${retry} order_id=${order_id} total=${total}",
	})

	// Example 1: Trace ID only
	traceID := rand.TraceID()
	glog.Info(traceID) // string message only

	// Example 2: Trace ID as field
	glog.Info("Start request", glog.Fields{
		"TRACE": traceID,
	})

	// Example 3: Debug message with custom field
	glog.Debug("This is a debug message", glog.Fields{
		"user": gcolor.
			New().
			Fg("yellow").
			Sprint("jeffotoni"),
	})

	// Example 4: Formatted info message (uses sprintf-style)
	glog.Infof("User %s logged in successfully", "arthur")

	// Example 5: Warning with simple string
	glog.Warn("Low disk space warning")

	// Example 6: Error with custom retry field
	glog.Error("Database connection failed", glog.Fields{
		"retry": true,
	})

	// Example 7: Simulated order processing log
	glog.Info("Processing order", glog.Fields{
		"order_id": "ORD1234",
		"customer": "Alice",
		"total":    153.76,
	})
}

[jeffotoni]

new pkgs for Quick, now we have native glog and gcolor, so we can make our APIs even more complete.

glog is the same idea as the logger middleware, that is, the same base and structure, the logs have become standard in Quick.

We still need to carry out tests with examples demonstrating the possible combinations that can be made with gcolor and glogs in Quick.

There is still a lot missing, but version 0.0.1 has been released, now it is time to play around and improve.

I hope you like it 🩷🚀🥰💕🐧

@GuilhermeCaruso
@emmadal
@davisbento
@jaquelineabreu
@marcos-dev88
@knbr13
@victorfernandesraton
@Aorts

[emmadal]

Good functionality. thanks @jeffotoni

[jeffotoni]

@emmadal

Sorry for not responding so quickly, I spent the days optimizing and refactoring glog, and I got very close to zerolog in the Benchmark
(lol) many sleepless nights today I uploaded an optimized version.
I got really excited... but now I'm trying to get back to normal.
I'll show you the results of benchmark

glog vs zerolog => we are close to them

This is important for our CLI, because it can generate the examples with contexts etc. and logs etc.

I'll send the example 🚀🔥🐧

Example glog with Ctx and api

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"time"

	"github.com/jeffotoni/quick"
	"github.com/jeffotoni/quick/pkg/glog"
	"github.com/jeffotoni/quick/pkg/rand"
)

const KeyName string = "X-Trace-ID"

// curl -i -XPOST -H "Content-Type:application/json" localhost:8080/v1/user -d '{"name": "jeff", "year": 2025}'
func main() {

	logger := glog.Set(glog.Config{
		Format: "json",
		Level:  glog.DEBUG,
	})

	q := quick.New()

	q.Post("/v1/user", func(c *quick.Ctx) error {
		// creating a trace
		traceID := c.Get("X-Trace-ID")
		if traceID == "" {
			traceID = rand.TraceID()
		}

		userID := rand.AlgoDefault(9000, 9000)
		spanID := "span39393"

		ctx, cancel := glog.CreateCtx().
			Set("X-Trace-ID", traceID).
			Set("X-User-ID", userID).
			Set("X-Span-ID", spanID).
			Timeout(10 * time.Second).
			Build()
		defer cancel()

		c.Set("X-Trace-ID", traceID)
		c.Set("X-User-ID", userID)
		c.Set("X-Span-ID", spanID)

		c.Set("Content-type", "application/json")
		var d any
		err := c.BodyParser(&d)
		if err != nil {
			logger.Error().
				Time().
				Level().
				Str(KeyName, traceID).
				Str("error", err.Error()).
				Send()
			return c.Status(500).JSON(quick.M{"msg": err.Error()})
		}

		logger.Debug().
			Time().
			Level().
			Str(KeyName, traceID).
			Str("func", "BodyParser").
			Str("status", "success").
			// Caller().
			Send()

		// call metodh
		b, err := SaveSomeWhere(ctx, logger, d)
		if err != nil {
			logger.Error().
				Time().
				Level().
				Str(KeyName, traceID).
				Str("Error", err.Error()).
				Send()

			return c.Status(500).JSON(quick.M{"msg": err.Error()})
		}

		logger.Debug().
			Time().
			Level().
			Str(KeyName, traceID).
			Str("func", "SaveSomeWhere").
			Int("code", quick.StatusOK).
			Msg("api-post-fluent").
			Send()

		all := glog.GetCtxAll(ctx)
		fmt.Printf("X-Trace-ID:%s X-User-ID:%s X-Span-ID:%s\n", all["X-Trace-ID"], all["X-User-ID"], all["X-Span-ID"])

		return c.Status(quick.StatusOK).Send(b)
	})

	q.Listen("0.0.0.0:8080")
}

func SaveSomeWhere(ctx context.Context, logger *glog.Logger, data any) (b []byte, err error) {
	traceID := glog.GetCtx(ctx, KeyName)
	b, err = json.Marshal(data)
	if err != nil {
		logger.Error().
			Time().
			Level().
			Str(KeyName, traceID).
			Str("Error", err.Error()).
			Send()

		return
	}

	err = SendQueue(ctx, logger, b)
	if err != nil {
		logger.Error().
			Time().
			Level().
			Str(KeyName, traceID).
			Str("Error", err.Error()).
			Send()

		return nil, err
	}

	logger.Debug().
		Time().
		Level().
		Str(KeyName, traceID).
		Str("func", "Marshal").
		Str("status", "success").
		Send()

	return
}

func SendQueue(ctx context.Context, logger *glog.Logger, data []byte) (err error) {
	// send SQS
	time.Sleep(time.Millisecond * 100)

	logger.Debug().
		Time().
		Level().
		Str(KeyName, glog.GetCtx(ctx, KeyName)).
		Str("func", "SendSQS").
		Str("status", "success").
		Send()

	return
}

[emmadal]

Hello @jeffotoni

Ok no worries i understand, good job. that's a good improvements.
why we can't enable by default the request logging in text format to allow user to see datetime of request, execution time, route called a little like gin or nestjs ?