ozzo-log: github.com/go-ozzo/ozzo-log Index | Examples | Files

package log

import "github.com/go-ozzo/ozzo-log"

Package log implements logging with severity levels and message categories.

Index

Examples

Package Files

console.go file.go filter.go logger.go mail.go network.go

Variables

var LevelNames = map[Level]string{
    LevelDebug:     "Debug",
    LevelInfo:      "Info",
    LevelNotice:    "Notice",
    LevelWarning:   "Warning",
    LevelError:     "Error",
    LevelCritical:  "Critical",
    LevelAlert:     "Alert",
    LevelEmergency: "Emergency",
}

LevelNames maps log levels to names

func DefaultFormatter Uses

func DefaultFormatter(l *Logger, e *Entry) string

DefaultFormatter is the default formatter used to format every log message.

func GetCallStack Uses

func GetCallStack(skip int, frames int, filter string) string

GetCallStack returns the current call stack information as a string. The skip parameter specifies how many top frames should be skipped, while the frames parameter specifies at most how many frames should be returned.

type ConsoleTarget Uses

type ConsoleTarget struct {
    *Filter
    ColorMode bool      // whether to use colors to differentiate log levels
    Writer    io.Writer // the writer to write log messages
    // contains filtered or unexported fields
}

ConsoleTarget writes filtered log messages to console window.

func NewConsoleTarget Uses

func NewConsoleTarget() *ConsoleTarget

NewConsoleTarget creates a ConsoleTarget. The new ConsoleTarget takes these default options: MaxLevel: LevelDebug, ColorMode: true, Writer: os.Stdout

Code:

logger := log.NewLogger()

// creates a ConsoleTarget with color mode being disabled
target := log.NewConsoleTarget()
target.ColorMode = false

logger.Targets = append(logger.Targets, target)

logger.Open()

// ... logger is ready to use ...

func (*ConsoleTarget) Close Uses

func (t *ConsoleTarget) Close()

Close closes the console target.

func (*ConsoleTarget) Open Uses

func (t *ConsoleTarget) Open(io.Writer) error

Open prepares ConsoleTarget for processing log messages.

func (*ConsoleTarget) Process Uses

func (t *ConsoleTarget) Process(e *Entry)

Process writes a log message using Writer.

type Entry Uses

type Entry struct {
    Level     Level
    Category  string
    Message   string
    Time      time.Time
    CallStack string

    FormattedMessage string
}

Entry represents a log entry.

func (*Entry) String Uses

func (e *Entry) String() string

String returns the string representation of the log entry

type FileTarget Uses

type FileTarget struct {
    *Filter
    // the log file name. When Rotate is true, log file name will be suffixed
    // to differentiate different backup copies (e.g. app.log.1)
    FileName string
    // whether to enable file rotating at specific time interval or when maximum file size is reached.
    Rotate bool
    // how many log files should be kept when Rotate is true (the current log file is not included).
    // This field is ignored when Rotate is false.
    BackupCount int
    // maximum number of bytes allowed for a log file. Zero means no limit.
    // This field is ignored when Rotate is false.
    MaxBytes int64
    // contains filtered or unexported fields
}

FileTarget writes filtered log messages to a file. FileTarget supports file rotation by keeping certain number of backup log files.

func NewFileTarget Uses

func NewFileTarget() *FileTarget

NewFileTarget creates a FileTarget. The new FileTarget takes these default options: MaxLevel: LevelDebug, Rotate: true, BackupCount: 10, MaxBytes: 1 << 20 You must specify the FileName field.

Code:

logger := log.NewLogger()

// creates a FileTarget which keeps log messages in the app.log file
target := log.NewFileTarget()
target.FileName = "app.log"

logger.Targets = append(logger.Targets, target)

logger.Open()

// ... logger is ready to use ...

func (*FileTarget) Close Uses

func (t *FileTarget) Close()

Close closes the file target.

func (*FileTarget) Open Uses

func (t *FileTarget) Open(errWriter io.Writer) error

Open prepares FileTarget for processing log messages.

func (*FileTarget) Process Uses

func (t *FileTarget) Process(e *Entry)

Process saves an allowed log message into the log file.

type Filter Uses

type Filter struct {
    MaxLevel   Level    // the maximum severity level that is allowed
    Categories []string // the allowed message categories. Categories can use "*" as a suffix for wildcard matching.
    // contains filtered or unexported fields
}

Filter checks if a log message meets the level and category requirements.

func (*Filter) Allow Uses

func (t *Filter) Allow(e *Entry) bool

Allow checks if a message meets the severity level and category requirements.

func (*Filter) Init Uses

func (t *Filter) Init()

Init initializes the filter. Init must be called before Allow is called.

type Formatter Uses

type Formatter func(*Logger, *Entry) string

Formatter formats a log message into an appropriate string.

type Level Uses

type Level int

Level describes the level of a log message.

const (
    LevelEmergency Level = iota
    LevelAlert
    LevelCritical
    LevelError
    LevelWarning
    LevelNotice
    LevelInfo
    LevelDebug
)

RFC5424 log message levels.

func (Level) String Uses

func (l Level) String() string

String returns the string representation of the log level

type Logger Uses

type Logger struct {
    Category  string    // the category associated with this logger
    Formatter Formatter // message formatter
    // contains filtered or unexported fields
}

Logger records log messages and dispatches them to various targets for further processing.

func NewLogger Uses

func NewLogger() *Logger

NewLogger creates a root logger. The new logger takes these default options: ErrorWriter: os.Stderr, BufferSize: 1024, MaxLevel: LevelDebug, Category: app, Formatter: DefaultFormatter

func (*Logger) Alert Uses

func (l *Logger) Alert(format string, a ...interface{})

Alert logs a message indicating action must be taken immediately. Please refer to Error() for how to use this method.

func (Logger) Close Uses

func (l Logger) Close()

Close closes the logger and the targets. Existing messages will be processed before the targets are closed. New incoming messages will be discarded after calling this method.

func (*Logger) Critical Uses

func (l *Logger) Critical(format string, a ...interface{})

Critical logs a message indicating critical conditions. Please refer to Error() for how to use this method.

func (*Logger) Debug Uses

func (l *Logger) Debug(format string, a ...interface{})

Debug logs a message for debugging purpose. Please refer to Error() for how to use this method.

func (*Logger) Emergency Uses

func (l *Logger) Emergency(format string, a ...interface{})

Emergency logs a message indicating the system is unusable. Please refer to Error() for how to use this method.

func (*Logger) Error Uses

func (l *Logger) Error(format string, a ...interface{})

Error logs a message indicating an error condition. This method takes one or multiple parameters. If a single parameter is provided, it will be treated as the log message. If multiple parameters are provided, they will be passed to fmt.Sprintf() to generate the log message.

Code:

logger := log.NewLogger()

logger.Targets = append(logger.Targets, log.NewConsoleTarget())

logger.Open()

// log without formatting
logger.Error("a plain message")
// log with formatting
logger.Error("the value is: %v", 100)

func (*Logger) GetLogger Uses

func (l *Logger) GetLogger(category string, formatter ...Formatter) *Logger

GetLogger creates a logger with the specified category and log formatter. Messages logged through this logger will carry the same category name. The formatter, if not specified, will inherit from the calling logger. It will be used to format all messages logged through this logger.

func (*Logger) Info Uses

func (l *Logger) Info(format string, a ...interface{})

Info logs a message for informational purpose. Please refer to Error() for how to use this method.

func (*Logger) Log Uses

func (l *Logger) Log(level Level, format string, a ...interface{})

Log logs a message of a specified severity level.

func (*Logger) Notice Uses

func (l *Logger) Notice(format string, a ...interface{})

Notice logs a message meaning normal but significant condition. Please refer to Error() for how to use this method.

func (Logger) Open Uses

func (l Logger) Open() error

Open prepares the logger and the targets for logging purpose. Open must be called before any message can be logged.

func (*Logger) Warning Uses

func (l *Logger) Warning(format string, a ...interface{})

Warning logs a message indicating a warning condition. Please refer to Error() for how to use this method.

type MailTarget Uses

type MailTarget struct {
    *Filter
    Host       string   // SMTP server address
    Username   string   // SMTP server login username
    Password   string   // SMTP server login password
    Subject    string   // the mail subject
    Sender     string   // the mail sender
    Recipients []string // the mail recipients
    BufferSize int      // the size of the message channel.
    // contains filtered or unexported fields
}

MailTarget sends log messages in emails via an SMTP server.

func NewMailTarget Uses

func NewMailTarget() *MailTarget

NewMailTarget creates a MailTarget. The new MailTarget takes these default options: MaxLevel: LevelDebug, BufferSize: 1024. You must specify these fields: Host, Username, Subject, Sender, and Recipients.

Code:

logger := log.NewLogger()

// creates a MailTarget which sends emails to admin@example.com
target := log.NewMailTarget()
target.Host = "smtp.example.com"
target.Username = "foo"
target.Password = "bar"
target.Subject = "log messages for foobar"
target.Sender = "admin@example.com"
target.Recipients = []string{"admin@example.com"}

logger.Targets = append(logger.Targets, target)

logger.Open()

// ... logger is ready to use ...

func (*MailTarget) Close Uses

func (t *MailTarget) Close()

Close closes the mail target.

func (*MailTarget) Open Uses

func (t *MailTarget) Open(errWriter io.Writer) error

Open prepares MailTarget for processing log messages.

func (*MailTarget) Process Uses

func (t *MailTarget) Process(e *Entry)

Process puts filtered log messages into a channel for sending in emails.

type NetworkTarget Uses

type NetworkTarget struct {
    *Filter
    // the network to connect to. Valid networks include
    // tcp", "tcp4" (IPv4-only), "tcp6" (IPv6-only),
    // "udp", "udp4" (IPv4-only), "udp6" (IPv6-only), "ip", "ip4"
    // (IPv4-only), "ip6" (IPv6-only), "unix", "unixgram" and
    // "unixpacket".
    Network string
    // the address on the network to connect to.
    // For TCP and UDP networks, addresses have the form host:port.
    // If host is a literal IPv6 address it must be enclosed
    // in square brackets as in "[::1]:80" or "[ipv6-host%zone]:80".
    Address string
    // whether to use a persistent network connection.
    // If this is false, for every message to be sent, a network
    // connection will be open and closed.
    Persistent bool
    // the size of the message channel.
    BufferSize int
    // contains filtered or unexported fields
}

NetworkTarget sends log messages over a network connection.

func NewNetworkTarget Uses

func NewNetworkTarget() *NetworkTarget

NewNetworkTarget creates a NetworkTarget. The new NetworkTarget takes these default options: MaxLevel: LevelDebug, Persistent: true, BufferSize: 1024. You must specify the Network and Address fields.

Code:

logger := log.NewLogger()

// creates a NetworkTarget which uses tcp network and address :10234
target := log.NewNetworkTarget()
target.Network = "tcp"
target.Address = ":10234"

logger.Targets = append(logger.Targets, target)

logger.Open()

// ... logger is ready to use ...

func (*NetworkTarget) Close Uses

func (t *NetworkTarget) Close()

Close closes the network target.

func (*NetworkTarget) Open Uses

func (t *NetworkTarget) Open(errWriter io.Writer) error

Open prepares NetworkTarget for processing log messages.

func (*NetworkTarget) Process Uses

func (t *NetworkTarget) Process(e *Entry)

Process puts filtered log messages into a channel for sending over network.

type Target Uses

type Target interface {
    // Open prepares the target for processing log messages.
    // Open will be invoked when Logger.Open() is called.
    // If an error is returned, the target will be removed from the logger.
    // errWriter should be used to write errors found while processing log messages.
    Open(errWriter io.Writer) error
    // Process processes an incoming log message.
    Process(*Entry)
    // Close closes a target.
    // Close is called when Logger.Close() is called, which gives each target
    // a chance to flush the logged messages to their destination storage.
    Close()
}

Target represents a target where the logger can send log messages to for further processing.

Package log imports 11 packages (graph) and is imported by 1 packages. Updated 2016-07-16. Refresh now. Tools for package owners.