Popularity

4.5

Growing

Activity

5.6

Stars 110

Watchers 6

Forks 10

Last Commit about 2 hours ago

Programming language: Go

License: MIT License

Tags: Logging

Latest version: v1.5.1

glg alternatives and similar packages

Based on the "Logging" category.
Alternatively, view glg alternatives based on common mentions on social networks and blogs.

logrus

9.9 6.1 glg VS logrus

a structured logger for Go.
zap

9.8 5.8 glg VS zap

Fast, structured, leveled logging in Go

Scout APM - Leading-edge performance monitoring starting at $39/month

Scout APM uses tracing logic that ties bottlenecks to source code so you know the exact line of code causing performance issues and can get back to building a great product faster.

Sponsored scoutapm.com

zerolog

9.2 5.6 glg VS zerolog

Zero-allocation JSON logger.
spew

9.1 0.0 glg VS spew

Implements a deep pretty printer for Go data structures to aid in debugging
glog

9.0 0.0 glg VS glog

Leveled execution logs for Go.
lumberjack

8.8 0.6 glg VS lumberjack

Simple rolling logger, implements io.WriteCloser.
tail

8.7 0.0 glg VS tail

A Go package striving to emulate the features of the BSD tail program.
seelog

8.4 0.0 glg VS seelog

logging functionality with flexible dispatching, filtering, and formatting.
log15

7.7 0.6 glg VS log15

Simple, powerful logging for Go
log

7.7 4.5 glg VS log

Structured logging package for Go.
logutils

7.4 0.0 glg VS logutils

Utilities for slightly better logging in Go (Golang) extending the standard logger.
phuslu/log

6.2 8.7 glg VS phuslu/log

Structured Logging Made Easy.
logxi

6.2 0.0 glg VS logxi

A 12-factor app logger that is fast and makes you happy.
Onelog

6.2 0.0 glg VS Onelog

Dead simple, super fast, zero allocation and modular logger for Golang
go-logger

6.0 0.0 glg VS go-logger

Simple logger of Go Programs, with level handlers.
logrusiowriter

5.6 0.3 glg VS logrusiowriter

io.Writer implementation using logrus logger.
loggo

5.5 0.2 glg VS loggo

A logging library for Go. Doesn't use the built in go log standard library, but instead offers a replacement.
rollingwriter

5.3 1.6 glg VS rollingwriter

RollingWriter is an auto-rotate io.Writer implementation with multi policies to provide log file rotation.
httpretty

5.3 1.8 glg VS httpretty

Pretty-prints your regular HTTP requests on your terminal for debugging (similar to http.DumpRequest).
ozzo-log

5.1 0.0 glg VS ozzo-log

High performance logging supporting log severity, categorization, and filtering. Can send filtered log messages to various targets (e.g. console, network, mail).
logger

4.9 0.6 glg VS logger

Minimalistic logging library for Go.
xlog

4.8 0.0 glg VS xlog

A structured logger for net/context aware HTTP handlers with flexible dispatching.
sqldb-logger

4.8 5.2 glg VS sqldb-logger

A logger for Go SQL database driver without modify existing *sql.DB stdlib usage.
logur

4.6 5.1 glg VS logur

An opinionated logger interface and collection of logging best practices with adapters and integrations for well-known libraries (logrus, go-kit log, zap, zerolog, etc).
log-voyage

4.2 0.0 glg VS log-voyage

Full-featured logging saas written in golang.
logex

3.3 0.0 glg VS logex

An golang log lib, supports tracking and level, wrap by standard log lib
gologger

3.3 0.0 glg VS gologger

Simple easy to use log lib for go, logs in Colored Cosole, Simple Console, File or Elasticsearch.
go-log

3.3 0.0 glg VS go-log

Log lib supports level and multi handlers.
stdlog

3.2 0.0 glg VS stdlog

Stdlog is an object-oriented library providing leveled logging. It is very useful for cron jobs.
logrusly

3.1 0.0 glg VS logrusly

logrus plug-in to send errors to a Loggly.
mlog

3.0 0.0 glg VS mlog

A simple logging module for go, with 5 levels, an optional rotating logfile feature and stdout/stderr output.
go-cronowriter

2.9 2.5 glg VS go-cronowriter

A simple writer that rotate log files automatically based on current date and time, like cronolog.
distillog

2.4 0.0 glg VS distillog

distilled levelled logging (think of it as stdlib + log levels).
slf

2.3 1.4 glg VS slf

The Structured Logging Facade (SLF) for Go (like SLF4J but structured and for Go)
journald

2.1 0.0 glg VS journald

Go implementation of systemd Journal's native API for logging.
Kiwi Logs&Context

2.1 0.4 glg VS Kiwi Logs&Context

Structured logger & context keeper for Go language
slog

1.8 2.1 glg VS slog

The reference implementation of the Structured Logging Facade (SLF) for Go
gomol

1.6 0.0 glg VS gomol

Gomol is a library for structured, multiple-output logging for Go with extensible logging outputs
logmatic

1.6 0.9 glg VS logmatic

Colorized logger for Golang with dynamic log level configuration.
logdump

1.4 0.0 glg VS logdump

Package for multi-level logging
zkits-logger

1.3 7.4 glg VS zkits-logger

A powerful zero-dependency JSON logger.
logo

1.3 0.0 glg VS logo

Golang logger to different configurable writers.
glo

1.2 0.0 glg VS glo

PHP Monolog inspired logging facility with identical severity levels.
go-rethinklogger

0.8 0.0 glg VS go-rethinklogger

Automatically persists all the logs of your Go application inside RethinkDB.
yell

0.5 5.9 glg VS yell

Yet another minimalistic logging library.
kemba

0.5 5.4 glg VS kemba

A tiny debug logging tool inspired by debug, great for CLI tools and applications.
MrZ's go-logger

0.4 5.1 glg VS MrZ's go-logger

Easy to use, extendable and super fast logging package for Go
gone/log

0.2 - glg VS gone/log

Fast, extendable, full-featured, std-lib source compatible log library.

Do you think we are missing an alternative of glg or a related project?

Add another 'Logging' Package

Popular Comparisons

README

glg is simple golang logging library

Requirement

Go 1.11

Installation

go get github.com/kpango/glg

Example

package main

import (
    "net/http"
    "time"

    "github.com/kpango/glg"
)

// NetWorkLogger sample network logger
type NetWorkLogger struct{}

func (n NetWorkLogger) Write(b []byte) (int, error) {
    // http.Post("localhost:8080/log", "", bytes.NewReader(b))
    http.Get("http://127.0.0.1:8080/log")
    glg.Success("Requested")
    glg.Infof("RawString is %s", glg.RawString(b))
    return 1, nil
}

func main() {

    // var errWriter io.Writer
    // var customWriter io.Writer
    infolog := glg.FileWriter("/tmp/info.log", 0666)

    customTag := "FINE"
    customErrTag := "CRIT"

    errlog := glg.FileWriter("/tmp/error.log", 0666)
    defer infolog.Close()
    defer errlog.Close()
    glg.Get().
        SetMode(glg.BOTH). // default is STD
        // DisableColor().
        // SetMode(glg.NONE).
        // SetMode(glg.WRITER).
        // SetMode(glg.BOTH).
        // InitWriter().
        // AddWriter(customWriter).
        // SetWriter(customWriter).
        // AddLevelWriter(glg.LOG, customWriter).
        // AddLevelWriter(glg.INFO, customWriter).
        // AddLevelWriter(glg.WARN, customWriter).
        // AddLevelWriter(glg.ERR, customWriter).
        // SetLevelWriter(glg.LOG, customWriter).
        // SetLevelWriter(glg.INFO, customWriter).
        // SetLevelWriter(glg.WARN, customWriter).
        // SetLevelWriter(glg.ERR, customWriter).
        AddLevelWriter(glg.INFO, infolog).                         // add info log file destination
        AddLevelWriter(glg.ERR, errlog).                           // add error log file destination
        AddStdLevel(customTag, glg.STD, false).                    //user custom log level
        AddErrLevel(customErrTag, glg.STD, true).                  // user custom error log level
        SetLevelColor(glg.TagStringToLevel(customTag), glg.Cyan).  // set color output to user custom level
        SetLevelColor(glg.TagStringToLevel(customErrTag), glg.Red) // set color output to user custom level

    glg.Info("info")
    glg.Infof("%s : %s", "info", "formatted")
    glg.Log("log")
    glg.Logf("%s : %s", "info", "formatted")
    glg.Debug("debug")
    glg.Debugf("%s : %s", "info", "formatted")
    glg.Warn("warn")
    glg.Warnf("%s : %s", "info", "formatted")
    glg.Error("error")
    glg.Errorf("%s : %s", "info", "formatted")
    glg.Success("ok")
    glg.Successf("%s : %s", "info", "formatted")
    glg.Fail("fail")
    glg.Failf("%s : %s", "info", "formatted")
    glg.Print("Print")
    glg.Println("Println")
    glg.Printf("%s : %s", "printf", "formatted")
    glg.CustomLog(customTag, "custom logging")
    glg.CustomLog(customErrTag, "custom error logging")

    glg.Get().AddLevelWriter(glg.DEBG, NetWorkLogger{}) // add info log file destination

    http.Handle("/glg", glg.HTTPLoggerFunc("glg sample", func(w http.ResponseWriter, r *http.Request) {
        glg.New().
        AddLevelWriter(glg.Info, NetWorkLogger{}).
        AddLevelWriter(glg.Info, w).
        Info("glg HTTP server logger sample")
    }))

    http.ListenAndServe("port", nil)

    // fatal logging
    glg.Fatalln("fatal")
}

Benchmarks

Contribution

Fork it ( https://github.com/kpango/glg/fork )
Create your feature branch (git checkout -b my-new-feature)
Commit your changes (git commit -am 'Add some feature')
Push to the branch (git push origin my-new-feature)
Create new Pull Request

Author

kpango

LICENSE

glg released under MIT license, refer LICENSE file.

*Note that all licence references and agreements mentioned in the glg README section above are relevant to that project's source code only.

glg

glg is simple and fast leveled logging library for Go.