logger

README

Go-logger

Level-based logger for Go apps.

Documentation

• API Reference

Installation

Install using the "go get" command:

go get -u github.com/FZambia/go-logger

License

MIT license.

Documentation

Overview

Package logger is a level-based logger for Go applications.

Example usage:

package main

import (
  "github.com/FZambia/go-logger"
)

func main() {
  name := "Alexander"
  logger.INFO.Printf("Hello %s", name)
  logger.ERROR.Println("Error")
}

Output:

[I]: 2016/09/09 19:41:13 Hello Alexander
[E]: 2016/09/09 19:41:13 Error

Index

• Variables
• func SetLogFile(path string) error
• func SetLogFlag(flag int)
• func SetLogThreshold(level Level)
• func SetStdoutThreshold(level Level)
• type Level
• type LevelLogger
  • func (n *LevelLogger) Enabled() bool
  • func (n *LevelLogger) Fatal(v ...interface{})
  • func (n *LevelLogger) Fatalf(format string, v ...interface{})
  • func (n *LevelLogger) Fatalln(v ...interface{})
  • func (n *LevelLogger) Panic(v ...interface{})
  • func (n *LevelLogger) Panicf(format string, v ...interface{})
  • func (n *LevelLogger) Panicln(v ...interface{})
  • func (n *LevelLogger) Print(v ...interface{})
  • func (n *LevelLogger) Printf(format string, v ...interface{})
  • func (n *LevelLogger) Println(v ...interface{})
  • func (n *LevelLogger) Write(p []byte) (int, error)

Variables

var (
	LogHandle  io.Writer = ioutil.Discard
	OutHandle  io.Writer = os.Stdout
	BothHandle io.Writer = io.MultiWriter(LogHandle, OutHandle)

	Flag int = log.Ldate | log.Ltime

	TRACE    *LevelLogger = &LevelLogger{level: LevelTrace, logger: logger, prefix: "[T]: "}
	DEBUG    *LevelLogger = &LevelLogger{level: LevelDebug, logger: logger, prefix: "[D]: "}
	INFO     *LevelLogger = &LevelLogger{level: LevelInfo, logger: logger, prefix: "[I]: "}
	WARN     *LevelLogger = &LevelLogger{level: LevelWarn, logger: logger, prefix: "[W]: "}
	ERROR    *LevelLogger = &LevelLogger{level: LevelError, logger: logger, prefix: "[E]: "}
	CRITICAL *LevelLogger = &LevelLogger{level: LevelCritical, logger: logger, prefix: "[C]: "}
	FATAL    *LevelLogger = &LevelLogger{level: LevelFatal, logger: logger, prefix: "[F]: "}
)

var LevelMatches = map[string]Level{
	"TRACE":    LevelTrace,
	"DEBUG":    LevelDebug,
	"INFO":     LevelInfo,
	"WARN":     LevelWarn,
	"ERROR":    LevelError,
	"CRITICAL": LevelCritical,
	"FATAL":    LevelFatal,
	"NONE":     LevelNone,
}

Functions

func SetLogFile

func SetLogFile(path string) error

SetLogFile sets the LogHandle to a io.writer created for the file behind the given file path. Will append to this file.

func SetLogFlag

func SetLogFlag(flag int)

SetLogFlag sets global log flag used in package.

func SetLogThreshold

func SetLogThreshold(level Level)

SetLogThreshold establishes a threshold where anything matching or above will be logged.

func SetStdoutThreshold

func SetStdoutThreshold(level Level)

SetStdoutThreshold establishes a threshold where anything matching or above will be output.

Types

type Level

type Level int

Level describes the chosen log level

const (
	LevelTrace Level = iota
	LevelDebug
	LevelInfo
	LevelWarn
	LevelError
	LevelCritical
	LevelFatal
	LevelNone

	DefaultLogThreshold    = LevelInfo
	DefaultStdoutThreshold = LevelInfo
)

type LevelLogger

type LevelLogger struct {
	// contains filtered or unexported fields
}

LevelLogger represents levelled logger.

func (*LevelLogger) Enabled

func (n *LevelLogger) Enabled() bool

Enabled exists to prevent calling underlying logger methods when not needed. This can also called from library users before calling LevelLogger methods to reduce allocations.

func (*LevelLogger) Fatal

func (n *LevelLogger) Fatal(v ...interface{})

Fatal calls underlying Logger Fatal func.

func (*LevelLogger) Fatalf

func (n *LevelLogger) Fatalf(format string, v ...interface{})

Fatalf calls underlying Logger Fatalf func.

func (*LevelLogger) Fatalln

func (n *LevelLogger) Fatalln(v ...interface{})

Fatalln calls underlying Logger Fatalln func.

func (*LevelLogger) Panic

func (n *LevelLogger) Panic(v ...interface{})

Panic calls underlying Logger Panic func.

func (*LevelLogger) Panicf

func (n *LevelLogger) Panicf(format string, v ...interface{})

Panicf calls underlying Logger Panicf func.

func (*LevelLogger) Panicln

func (n *LevelLogger) Panicln(v ...interface{})

Panicln calls underlying Logger Panicln func.

func (*LevelLogger) Print

func (n *LevelLogger) Print(v ...interface{})

Print calls underlying Logger Print func.

func (*LevelLogger) Printf

func (n *LevelLogger) Printf(format string, v ...interface{})

Printf calls underlying Logger Printf func.

func (*LevelLogger) Println

func (n *LevelLogger) Println(v ...interface{})

Println calls underlying Logger Println func.

func (*LevelLogger) Write

func (n *LevelLogger) Write(p []byte) (int, error)

Write allows LevelLogger to implement io.Writer interface so we can use it as output for other loggers.