sypl

package module
v1.19.20 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 22, 2024 License: MIT Imports: 19 Imported by: 38

README

sypl

Go

sypl provides a Simple Yet Powerful Logger built on top of the Golang sypl. A sypl logger can have many Outputs, and each Output is responsible for writing to a specified destination. Each Output can have multiple Processors, which run in isolation manipulating the log message. The order of execution is important, and is according to the registering (add) order. These features allow sypl to fit into many different logging flows.

Install

$ go get github.com/thalesfsp/sypl

Specific version

Example: $ go get github.com/thalesfsp/sypl@v1.2.0

Usage

See example_test.go, and sypl_test.go file.

Documentation

Run $ make doc or check out online.

How it works

A picture worth thousand words.

high-level-arch

Development

Check out CONTRIBUTION.

Release
  1. Update CHANGELOG accordingly.
  2. Once changes from MR are merged.
  3. Tag and release.

Roadmap

Check out CHANGELOG.

Documentation

Overview

Package sypl provides a Simple Yet Powerful Logger built on top of the Golang logger. A sypl logger can have many `Output`s, and each `Output` is responsible for writing to a specified destination. Each Output can have multiple `Processor`s, which run in isolation manipulating the log message. The order of execution is according to the registering order. The above features allow sypl to fit into many different logging flows and needs.

In a application with many loggers, and child loggers, sometimes more fine control is needed, specially when debugging applications. Sypl offers two powerful ways to achieve that: `SYPL_FILTER`, and `SYPL_DEBUG` env vars.

`SYPL_FILTER` allows to specify the name(s) of the component(s) that should be logged, for example, for a given application with the following loggers: `svc`, `pv`, and `cm`, if a developer wants only to see `svc`, and `pv` logging, it's achieved just setting `SYPL_FILTER="svc,pv"`.

`SYPL_DEBUG` allows to specify the max level, for example, for a given application with the following loggers: `svc`, `pv`, and `cm`, if a developer sets:

  • `SYPL_DEBUG="debug"`: any application running using Sypl, any component, any output, will log messages bellow the `debug` level
  • `SYPL_DEBUG="console:debug"`: any application running using Sypl with an output called `console`, will log messages bellow the `debug` level
  • `SYPL_DEBUG="warn,console:debug"`: any application running using Sypl, any component, any output, will log messages bellow the `warn` level, AND any application running using Sypl with an output called `console`, will log messages bellow the `debug` level. NOTE that `warn` is specified first. Only for this case - global max level scope, it's a requirement! In this case -> `SYPL_DEBUG="console:debug,warn"`, `warn` will be discarded.
  • `SYPL_DEBUG="svc:console:debug"`: any application running using Sypl with a component called `svc` with an output called `console`, will log messages bellow the `debug` level
  • `SYPL_DEBUG="file:warn,svc:console:debug"`: any application running using Sypl with an output called `file` will log messages bellow the `warn` level, and any application running using Sypl with a component called `svc` with an output called `console` will log messages bellow the `debug`.

The possibilities are endless! Checkout the [`debugAndFilter`](example_test.go) for more.

Index

Examples

Constants

This section is empty.

Variables

View Source 
var ErrSyplNotInitialized = errors.New("sypl isn't initialized. Have you instantiated it?")

ErrSyplNotInitialized is returned when sypl isn't initialized.

Functions

This section is empty.

Types

type IBasePrinter 

type IBasePrinter interface {
	// PrintMessage prints messages. It's a powerful option because it gives
	// full-control over the message. Use `New` to create the message.
	PrintMessage(messages ...message.IMessage) ISypl

	// PrintWithOptions is a more flexible way of printing, allowing to
	// specify a few message's options in a functional way. For full-control
	// over the message is possible via `PrintMessage`.
	PrintWithOptions(l level.Level, ct string, o ...OptionFunc) ISypl

	// PrintlnWithOptions is a more flexible way of printing, allowing to
	// specify a few message's options in a functional way. For full-control
	// over the message is possible via `PrintMessage`.
	PrintlnWithOptions(l level.Level, ct string, o ...OptionFunc) ISypl
}

IBasePrinter specifies the foundation for other printers.

type IBasicPrinter 

type IBasicPrinter interface {
	// Print just prints.
	Print(l level.Level, args ...interface{}) ISypl

	// Printf prints according with the specified format.
	Printf(l level.Level, format string, args ...interface{}) ISypl

	// Println prints, also adding a new line to the end.
	Println(l level.Level, args ...interface{}) ISypl
}

IBasicPrinter specifies the basic printers.

type IConvenientPrinter 

type IConvenientPrinter interface {
	// Printlnf prints according with the specified format, also adding a new
	// line to the end.
	Printlnf(l level.Level, format string, args ...interface{}) ISypl

	// PrintPretty prints data structures as JSON text.
	//
	// Notes:
	// - Only exported fields of the data structure will be printed.
	// - Message isn't processed.
	PrintPretty(l level.Level, data interface{}) ISypl

	// PrintlnPretty prints data structures as JSON text, also adding a new line
	// to the end.
	//
	// Notes:
	// - Only exported fields of the data structure will be printed.
	// - Message isn't processed.
	PrintlnPretty(l level.Level, data interface{}) ISypl

	// PrintMessagerPerOutput allows you to concurrently print messages, each
	// one, at the specified level and to the specified output.
	//
	// NOTE: If the named output doesn't exits, the message will not be printed.
	PrintMessagesToOutputs(messagesToOutputs ...MessageToOutput) ISypl

	// PrintMessagesToOutputsWithOptions allows you to concurrently print
	// messages, each one, at the specified level and to the specified output,
	// with options.
	//
	// NOTE: If the named output doesn't exits, the message will not be printed.
	PrintMessagesToOutputsWithOptions(o *options.Options, messagesToOutputs ...MessageToOutput) ISypl

	// PrintNewLine prints a new line. It always print, independent of the
	// level, and without any processing.
	PrintNewLine() ISypl
}

IConvenientPrinter specifies convenient printers.

type ILeveledPrinter 

type ILeveledPrinter interface {
	// Fatal prints, and exit with os.Exit(1).
	Fatal(args ...interface{}) ISypl

	// Fatalf prints according with the format, and exit with os.Exit(1).
	Fatalf(format string, args ...interface{}) ISypl

	// Fatallnf prints according with the format, also adding a new line to the
	// end, and exit with os.Exit(1).
	Fatallnf(format string, args ...interface{}) ISypl

	// Fatalln prints, also adding a new line and the end, and exit with
	// os.Exit(1).
	Fatalln(args ...interface{}) ISypl

	// Error prints @ the Error level.
	Error(args ...interface{}) ISypl

	// Errorf prints according with the format @ the Error level.
	Errorf(format string, args ...interface{}) ISypl

	// Errorlnf prints according with the format @ the Error level, also adding
	// a new line to the end.
	Errorlnf(format string, args ...interface{}) ISypl

	// Errorln prints, also adding a new line to the end @ the Error level.
	Errorln(args ...interface{}) ISypl

	// Serror prints like Error, and returns an error with the non-processed
	// content.
	Serror(args ...interface{}) error

	// Serrorf prints like Errorf, and returns an error with the non-processed
	// content.
	Serrorf(format string, args ...interface{}) error

	// Serrorlnf prints like Errorlnf, and returns an error with the
	// non-processed content.
	Serrorlnf(format string, args ...interface{}) error

	// Serrorln prints like Errorln, and returns an error with the non-processed
	// content.
	Serrorln(args ...interface{}) error

	// Info prints @ the Info level.
	Info(args ...interface{}) ISypl

	// Infof prints according with the specified format @ the Info level.
	Infof(format string, args ...interface{}) ISypl

	// Infolnf prints according with the specified format @ the Info level, also
	// adding a new line to the end.
	Infolnf(format string, args ...interface{}) ISypl

	// Infoln prints, also adding a new line to the end @ the Info level.
	Infoln(args ...interface{}) ISypl

	// Warn prints @ the Warn level.
	Warn(args ...interface{}) ISypl

	// Warnf prints according with the specified format @ the Warn level.
	Warnf(format string, args ...interface{}) ISypl

	// Warnlnf prints according with the specified format @ the Warn level, also
	// adding a new line to the end.
	Warnlnf(format string, args ...interface{}) ISypl

	// Warnln prints, also adding a new line to the end @ the Warn level.
	Warnln(args ...interface{}) ISypl

	// Debug prints @ the Debug level.
	Debug(args ...interface{}) ISypl

	// Debugf prints according with the specified format @ the Debug level.
	Debugf(format string, args ...interface{}) ISypl

	// Debuglnf prints according with the specified format @ the Debug level,
	// also adding a new line to the end.
	Debuglnf(format string, args ...interface{}) ISypl

	// Debugln prints, also adding a new line to the end @ the Debug level.
	Debugln(args ...interface{}) ISypl

	// Trace prints @ the Trace level.
	Trace(args ...interface{}) ISypl

	// Tracef prints according with the specified format @ the Trace level.
	Tracef(format string, args ...interface{}) ISypl

	// Tracelnf prints according with the specified format @ the Trace level,
	// also adding a new line to the end.
	Tracelnf(format string, args ...interface{}) ISypl

	// Traceln prints, also adding a new line to the end @ the Trace level.
	Traceln(args ...interface{}) ISypl
}

ILeveledPrinter specifies the leveled printers.

type IPrinters 

type IPrinters interface {
	IBasePrinter
	IBasicPrinter
	IConvenientPrinter
	ILeveledPrinter
}

IPrinters is all available printers.

type ISypl 

type ISypl interface {
	meta.IMeta
	IPrinters

	// GetDefaultIoWriterLevel returns the sypl status.
	GetDefaultIoWriterLevel() level.Level

	// SetDefaultIoWriterLevel sets the default io.Writer level.
	SetDefaultIoWriterLevel(l level.Level)

	// Breakpoint will stop execution waiting the user press "/n" ("enter") to
	// continue. It helps users doing log-to-console debug strategy. A message
	// with the breakpoint `name`, and PID of the process will be printed using
	// the `debug` level. Arbitrary `data` can optionally be set - if set, it'll
	// be printed. Errors are printed using the `error` level. Set logging level
	// to `trace` for more.
	Breakpoint(name string, data ...interface{}) ISypl

	// String interface.
	String() string

	// GetFields returns the global registered fields.
	GetFields() fields.Fields

	// SetFields sets global fields. Per-message fields has precedence over
	// global fields.
	SetFields(fields fields.Fields) ISypl

	// GetTags returns the global tags.
	GetTags() []string

	// SetTags sets the global tags.
	SetTags(tags ...string) ISypl

	// GetMaxLevel returns the `maxLevel` of all outputs.
	GetMaxLevel() map[string]level.Level

	// SetMaxLevel sets the `maxLevel` of all outputs.
	SetMaxLevel(l level.Level) ISypl

	// AddOutputs adds one or more outputs.
	AddOutputs(outputs ...output.IOutput) ISypl

	// GetOutput returns the registered output by its name. If not found, will be nil.
	GetOutput(name string) output.IOutput

	// SetOutputs sets one or more outputs. Use to update output(s).
	SetOutputs(outputs ...output.IOutput) ISypl

	// GetOutputs returns registered outputs.
	GetOutputs() []output.IOutput

	// GetOutputsNames returns the names of the registered outputs.
	GetOutputsNames() []string

	// New creates a child logger.
	New(name string) *Sypl

	// Writer implements the io.Writer interface. Message level will be the one set
	// via `SetIoWriterLevel`, default is `error`. It always returns `0, nil`.
	//
	// NOTE: This is a convenient method, if it doesn't fits your need, just
	// implement the way you need, as you would do.
	Write(p []byte) (n int, err error)
	// contains filtered or unexported methods
}

ISypl specified what a Sypl logger does.

type MessageToOutput 

type MessageToOutput struct {
	// Content to be printed.
	Content string

	// Level of the message.
	Level level.Level

	// OutputName name of the output.
	OutputName string
}

MessageToOutput defines a `Message` to printed at the specified `Level`, and to the specified `Output`.

type OptionFunc added in v1.7.0 

type OptionFunc func(m message.IMessage) message.IMessage

OptionFunc allows to specify message's options.

func WithField added in v1.9.16 

func WithField(key string, value any) OptionFunc

WithField allows to set a field for the error.

func WithFields added in v1.6.5 

func WithFields(fields fields.Fields) OptionFunc

WithFields add fields to a message.

func WithFlag added in v1.6.5 

func WithFlag(f flag.Flag) OptionFunc

WithFlag set message's flag.

func WithID added in v1.9.12 

func WithID(id string) OptionFunc

WithID set message's ID.

func WithOutputsNames added in v1.6.5 

func WithOutputsNames(outputsNames ...string) OptionFunc

WithOutputsNames set message's output names.

func WithProcessorsNames added in v1.6.5 

func WithProcessorsNames(processorsNames ...string) OptionFunc

WithProcessorsNames set message's processors names.

func WithTags added in v1.6.5 

func WithTags(tags ...string) OptionFunc

WithTags add tags to a message.

type Sypl 

type Sypl struct {
	// Name returns the logger name.
	//
	// NOTE: Exposed to deal with https://github.com/golang/go/issues/5819.
	Name string
	// contains filtered or unexported fields
}

Sypl logger definition.

func New 

func New(name string, outputs ...output.IOutput) *Sypl

New is the Sypl factory.

Example (Chained)

Chained is the chained example of creating, and setting up a `sypl` logger. It writes to both `stdout` and `stderr`. 

package main

import (
	"os"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/message"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/processor"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	// Creates logger, and name it.
	sypl.New("Testing Logger").
		// Creates a `Processor`. It will prefix all messages. It will only
		// prefix messages for this specific `Output`, and @ `Error` level.
		AddOutputs(output.New("Error", level.Error, os.Stdout).
			AddProcessors(func(prefix string) processor.IProcessor {
				return processor.New("Prefixer", func(message message.IMessage) error {
					if message.GetLevel() == level.Error {
						message.GetContent().SetProcessed(prefix + message.GetContent().GetProcessed())
					}

					return nil
				})
			}(shared.DefaultPrefixValue))).
		// Prints:
		// My Prefix - Test error message
		Println(level.Error, "Test error message")

}

Output:

My Prefix - Test error message
Example (ChainedUsingBuiltin)

ChainedUsingBuiltin is the chained example of creating, and setting up a `sypl` logger using built-in `Output`, and `Processor`. It writes to `stdout`, and `stderr`. 

package main

import (
	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/processor"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	// Creates logger, and name it.
	sypl.New("Testing Logger").
		// Adds an `Output`. In this case, called "Console" that will print to
		// `stdout` and max print level @ `Info`.
		//
		// Adds a `Processor`. It will prefix all messages.
		AddOutputs(output.Console(level.Info).AddProcessors(processor.Prefixer(shared.DefaultPrefixValue))).
		// Prints: My Prefix - Test info message
		Infoln("Test info message")

}

Output:

My Prefix - Test info message
Example (ChildLoggers)

Child loggers example. 

package main

import (
	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/formatter"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/status"
)

func main() {
	// Creates logger, and name it.
	k8Logger := sypl.New("k8").
		AddOutputs(output.Console(level.Info).SetFormatter(formatter.Text()))

	k8Logger.Infoln("k8 connected")

	podLogger := k8Logger.New("pod")
	podLogger.Infoln("pod created")

	k8Logger.GetOutput("Console").SetStatus(status.Disabled)

	k8Logger.Infoln("k8 connected")
	podLogger.Infoln("pod created")

	// Prints:
	//
	// k8 connected component=k8 level=info timestamp=2021-08-11T09:24:13-07:00
	// pod created component=pod level=info timestamp=2021-08-11T09:24:13-07:00
}

Output:
Example (DebugAndFilter)

Logging filtering, and debug capability example. 

package main

import (
	"os"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	// From any SYPL logger, bump all max levels to `info`
	// From any SYPL logger having a `console` output, bump max levels to `debug`
	// From a logger named `pod`, for its output called `Console`, bump max levels to `trace`
	// From a logger named `pv`, for its output called `o1`, bump max levels to `trace`
	os.Setenv(shared.LevelEnvVar, "info,console:debug,pod:console:trace,pv:o1:trace")
	defer os.Unsetenv(shared.LevelEnvVar)

	// From any SYPL logger, only print the following ones.
	os.Setenv(shared.FilterEnvVar, "pod,svc,vs,np,cm,pv")
	defer os.Unsetenv(shared.FilterEnvVar)

	// Will print, max level bumped to `trace` by `pod:console:trace`.
	sypl.New("pod").AddOutputs(output.Console(level.Error)).Traceln("pod created")

	// Will print, max level bumped to `debug`.
	sypl.New("svc").AddOutputs(output.Console(level.Error)).Debugln("svc created")

	// Will print, max level bumped to `debug`.
	sypl.New("vs").AddOutputs(output.Console(level.Error)).Debugln("vs created")

	// Will print, max level bumped to `debug`.
	sypl.New("np").AddOutputs(output.Console(level.Error)).Debugln("np created")

	// Will print, max level bumped to `debug`.
	sypl.New("cm").AddOutputs(output.Console(level.Error)).Debugln("cm created")

	sypl.New("pv").AddOutputs(
		// Will print, max level bumped to `trace` by `pv:o1:trace`.
		output.New("o1", level.Error, os.Stdout),
		// Will not print, max level bumped to `info` but less than `debug`.
		output.New("o2", level.Error, os.Stdout),
	).Traceln("pv created")

	// Will not print, max level bumped to `debug` but it's filtered out.
	sypl.New("dp").AddOutputs(output.Console(level.Error)).Debugln("dp created")

}

Output:

pod created
svc created
vs created
np created
cm created
pv created
Example (ErrorSimulator)

Simulates a problematic processor. 

package main

import (
	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/processor"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	// Creates logger, and name it.
	sypl.New(shared.DefaultComponentNameOutput).
		AddOutputs(output.Console(level.Info, processor.ErrorSimulator("Test"))).
		Infoln(shared.DefaultContentOutput)

	// Prints:
	//
	// 2021/08/10 20:00:56 [sypl] [Error] Output: "Console" Processor: "ErrorSimulator" Error: "Test" Original Message: "contentTest"
}

Output:
Example (Flags)

Flags example. 

package main

import (
	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/flag"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/processor"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	// Creates logger, and name it.
	sypl.New("Testing Logger", output.Console(level.Info, processor.Prefixer(shared.DefaultPrefixValue))).
		// Message will be processed, and printed independent of `Level`
		// restrictions.
		PrintlnWithOptions(level.Debug, shared.DefaultContentOutput, sypl.WithFlag(flag.Force)).

		// Message will be processed, but not printed.
		PrintlnWithOptions(level.Info, shared.DefaultContentOutput, sypl.WithFlag(flag.Mute)).

		// Message will not be processed, but printed.
		PrintlnWithOptions(level.Info, shared.DefaultContentOutput, sypl.WithFlag(flag.Skip)).

		// Should not print - restricted by level.
		Debugln(shared.DefaultContentOutput).

		// SkipAndForce message will not be processed, but will be printed
		// independent of `Level` restrictions.
		PrintlnWithOptions(level.Debug, shared.DefaultContentOutput, sypl.WithFlag(flag.SkipAndForce)).

		// Message will not be processed, neither printed.
		PrintlnWithOptions(level.Debug, shared.DefaultContentOutput, sypl.WithFlag(flag.SkipAndMute))

}

Output:

My Prefix - contentTest
contentTest
contentTest
Example (ForcePrintProcessor)

ForcePrint processor. 

package main

import (
	"fmt"
	"strings"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/flag"
	"github.com/thalesfsp/sypl/formatter"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/processor"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	buf, o := output.SafeBuffer(level.Info, processor.Flagger(flag.Force))

	o.SetFormatter(formatter.Text())

	// Creates logger, and name it.
	sypl.New(shared.DefaultComponentNameOutput, o).Traceln(shared.DefaultContentOutput)

	fmt.Print(strings.Contains(buf.String(), "message=contentTest"))

}

Output:

true
Example (GlobalFields)

Global fields example. 

package main

import (
	"fmt"
	"strings"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/fields"
	"github.com/thalesfsp/sypl/formatter"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/shared"
)

// Checks if `src` has `texts`. If not, it prints a message.
//
//nolint:forbidigo
func stringContains(src string, texts ...string) bool {
	contains := true

	for _, text := range texts {
		if !strings.Contains(src, text) {
			contains = false

			fmt.Printf("Expected %s to contain %s\n", src, text)
		}
	}

	return contains
}

func main() {
	buf, o := output.SafeBuffer(level.Info)

	// Creates logger, and name it.
	l := sypl.New(shared.DefaultComponentNameOutput, o.SetFormatter(formatter.Text()))
	l.SetFields(fields.Fields{"a": 1})

	l.Infoln(shared.DefaultContentOutput) // a=1

	l.PrintWithOptions(level.Info, shared.DefaultContentOutput,
		sypl.WithFields(fields.Fields{"a": 2, "b": 3}))

	l.Infoln(shared.DefaultContentOutput) // a=1

	fmt.Println(stringContains(buf.String(), "contentTest", "a=1", "a=2", "b=3"))

}

Output:

true
Example (GlobalTags)

Global tags example. 

package main

import (
	"fmt"
	"strings"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/formatter"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/shared"
)

// Checks if `src` has `texts`. If not, it prints a message.
//
//nolint:forbidigo
func stringContains(src string, texts ...string) bool {
	contains := true

	for _, text := range texts {
		if !strings.Contains(src, text) {
			contains = false

			fmt.Printf("Expected %s to contain %s\n", src, text)
		}
	}

	return contains
}

func main() {
	buf, o := output.SafeBuffer(level.Info)

	// Creates logger, and name it.
	l := sypl.New(shared.DefaultComponentNameOutput, o.SetFormatter(formatter.JSONPretty()))
	l.SetTags("a", "b")

	l.Infoln(shared.DefaultContentOutput) // a=1

	l.PrintWithOptions(level.Info, shared.DefaultContentOutput,
		sypl.WithTags("a", "c"))

	l.Infoln(shared.DefaultContentOutput) // a=1

	fmt.Println(stringContains(buf.String(), "contentTest", "tags", "a", "b", "c"))

}

Output:

true
Example (GlobalTagsNonDup)

Global tags example - non-duplicated tags. 

package main

import (
	"fmt"
	"strings"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/formatter"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/shared"
)

// Checks if `src` has `texts`. If not, it prints a message.
//
//nolint:forbidigo
func stringContains(src string, texts ...string) bool {
	contains := true

	for _, text := range texts {
		if !strings.Contains(src, text) {
			contains = false

			fmt.Printf("Expected %s to contain %s\n", src, text)
		}
	}

	return contains
}

func main() {
	buf, o := output.SafeBuffer(level.Info)

	// Creates logger, and name it.
	l := sypl.New(shared.DefaultComponentNameOutput, o.SetFormatter(formatter.JSONPretty()))
	l.SetTags("a", "b")

	l.PrintWithOptions(level.Info, shared.DefaultContentOutput,
		sypl.WithTags("a", "a", "c"))

	bufStr := buf.String()

	fmt.Println(strings.Count(bufStr, "\"a\""), stringContains(bufStr, "contentTest", "tags", "a", "b", "c"))

}

Output:

1 true
Example (InlineUsingBuiltin)

inlineUsingBuiltin same as `ChainedUsingBuiltin` but using inline form. 

package main

import (
	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/processor"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	sypl.New("Testing Logger", output.Console(level.Info).
		AddProcessors(processor.Prefixer(shared.DefaultPrefixValue))).
		Infoln("Test info message")

}

Output:

My Prefix - Test info message
Example (IoWriter)

Sypl as io.Writer, including sub-loggers thru interfaces. 

package main

import (
	"fmt"
	"strings"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/formatter"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/shared"
)

// Checks if `src` has `texts`. If not, it prints a message.
//
//nolint:forbidigo
func stringContains(src string, texts ...string) bool {
	contains := true

	for _, text := range texts {
		if !strings.Contains(src, text) {
			contains = false

			fmt.Printf("Expected %s to contain %s\n", src, text)
		}
	}

	return contains
}

func main() {
	buf, o := output.SafeBuffer(level.Trace)

	// Creates logger, and name it.
	l := sypl.New(shared.DefaultComponentNameOutput, o.SetFormatter(formatter.Text()))

	l.SetDefaultIoWriterLevel(level.Info)

	if _, err := l.Write([]byte(shared.DefaultContentOutput + "1 \n")); err != nil {
		fmt.Println(false)
	}

	l.SetDefaultIoWriterLevel(level.Warn)

	if _, err := l.Write([]byte(shared.DefaultContentOutput + "2 \n")); err != nil {
		fmt.Println(false)
	}

	var m sypl.ISypl

	m = l.New("sub")

	m.SetDefaultIoWriterLevel(level.Debug)

	if _, err := m.Write([]byte(shared.DefaultContentOutput + "3 \n")); err != nil {
		fmt.Println(false)
	}

	m.SetDefaultIoWriterLevel(level.Trace)

	if _, err := m.Write([]byte(shared.DefaultContentOutput + "4 \n")); err != nil {
		fmt.Println(false)
	}

	// Buf content should be...:
	// component=componentNameTest output=buffer level=info timestamp=2022-02-22T09:58:22-08:00 message=contentTest1
	// component=componentNameTest output=buffer level=warn timestamp=2022-02-22T09:58:22-08:00 message=contentTest2
	// component=sub output=buffer level=debug timestamp=2022-02-22T09:58:22-08:00 message=contentTest3
	// component=sub output=buffer level=trace timestamp=2022-02-22T09:58:22-08:00 message=contentTest4

	fmt.Println(stringContains(buf.String(),
		"componentNameTest",
		"sub",
		"contentTest1",
		"contentTest2",
		"contentTest3",
		"contentTest4",
		"info",
		"warn",
		"debug",
		"trace",
	))

}

Output:

true
Example (JsonFormatter)

JSON formatter example. 

package main

import (
	"fmt"
	"strings"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/fields"
	"github.com/thalesfsp/sypl/formatter"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	buf, o := output.SafeBuffer(level.Info)
	o.SetFormatter(formatter.JSONPretty())

	// Creates logger, and name it.
	sypl.New(shared.DefaultComponentNameOutput).
		AddOutputs(o).
		PrintWithOptions(
			level.Info,
			shared.DefaultContentOutput,
			sypl.WithFields(fields.Fields{
				"field1": "value1",
				"field2": 1,
				"field3": true,
				"field4": []string{"1", "2"},
			}),
		)

	s := buf.String()

	fmt.Print(
		strings.Contains(s, `"component"`),
		strings.Contains(s, `"message"`),
		strings.Contains(s, `"field1"`),
		strings.Contains(s, `"field2"`),
		strings.Contains(s, `"field3"`),
		strings.Contains(s, `"field4"`),
		strings.Contains(s, `"level"`),
		strings.Contains(s, `"timestamp"`),
	)

	// Prints:
	//
	// {
	// 	"component": "componentNameTest",
	// 	"content": "contentTest",
	// 	"field1": "value1",
	// 	"field2": 1,
	// 	"field3": true,
	// 	"field4": [
	// 		"1",
	// 		"2"
	// 	],
	// 	"level": "info",
	// 	"timestamp": "2021-08-10T23:27:25-07:00"
	// }

}

Output:

true true true true true true true true
Example (NewDefault)

NewDefault output example. 

package main

import (
	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	// Creates logger, and name it.
	sypl.NewDefault(shared.DefaultComponentNameOutput, level.Trace).
		Infoln(shared.DefaultContentOutput).
		Errorln("error message")

	// Prints:
	//
	// component=componentNameTest output=console level=info timestamp=2021-08-17T19:10:00-07:00 message=contentTest
	// component=componentNameTest output=console level=error timestamp=2021-08-17T19:10:00-07:00 message=error message
}

Output:
Example (NotChained)

NonChained is a non-chained example of creating, and setting up a `sypl` logger. It writes to a custom buffer. 

package main

import (
	"fmt"
	"strings"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/message"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/processor"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	buf := new(strings.Builder)

	// Creates logger, and name it.
	testingLogger := sypl.New("Testing Logger")

	// Creates an `Output`. In this case, called "Console" that will print to
	// `stdout` and max print level @ `Info`.
	ConsoleToStdOut := output.New("Console", level.Info, buf)

	// Creates a `Processor`. It will prefix all messages.
	Prefixer := func(prefix string) processor.IProcessor {
		return processor.New("Prefixer", func(message message.IMessage) error {
			message.GetContent().SetProcessed(prefix + message.GetContent().GetProcessed())

			return nil
		})
	}

	// Adds `Processor` to `Output`.
	ConsoleToStdOut.AddProcessors(Prefixer(shared.DefaultPrefixValue))

	// Adds `Output` to logger.
	testingLogger.AddOutputs(ConsoleToStdOut)

	// Writes: "My Prefix - Test message"
	testingLogger.Print(level.Info, "Test info message")

	fmt.Println(buf.String())

}

Output:

My Prefix - Test info message
Example (PrintMessagesToOutputs)

PrintMessagesToOutputs example. 

package main

import (
	"os"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/formatter"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
)

func main() {
	// Creates logger, and name it.
	sypl.New("pod").AddOutputs(
		output.New("Console 1", level.Trace, os.Stdout).SetFormatter(formatter.Text()),
		output.New("Console 2", level.Trace, os.Stdout).SetFormatter(formatter.Text()),
		output.New("Console 3", level.Trace, os.Stdout).SetFormatter(formatter.Text()),
	).PrintMessagesToOutputs(
		sypl.MessageToOutput{OutputName: "Console 1", Level: level.Info, Content: "Test 1\n"},
		sypl.MessageToOutput{OutputName: "Console 1", Level: level.Debug, Content: "Test 2\n"},
		sypl.MessageToOutput{OutputName: "Console 2", Level: level.Info, Content: "Test 3\n"},
		sypl.MessageToOutput{OutputName: "Console 4", Level: level.Info, Content: "Test 4\n"},
	)

	// Prints:
	//
	// output=Console 2 level=Info message=Test 3
	// output=Console 1 level=Debug message=Test 2
	// output=Console 1 level=Info message=Test 1
}

Output:
Example (PrintMessagesToOutputsWithOptions)

PrintMessagesToOutputsWithOptions example. 

package main

import (
	"fmt"
	"os"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/fields"
	"github.com/thalesfsp/sypl/formatter"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/options"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	// Creates logger, and name it.
	l := sypl.New(shared.DefaultComponentNameOutput).AddOutputs(
		output.New("Console 1", level.Trace, os.Stdout).SetFormatter(formatter.Text()),
		output.New("Console 2", level.Trace, os.Stdout).SetFormatter(formatter.Text()),
	)

	l.PrintMessagesToOutputsWithOptions(&options.Options{
		Fields: fields.Fields{"1": 2},
	},
		sypl.MessageToOutput{Content: fmt.Sprintln(shared.DefaultContentOutput), Level: level.Info, OutputName: "Console 1"},
		sypl.MessageToOutput{Content: fmt.Sprintln(shared.DefaultContentOutput), Level: level.Warn, OutputName: "Console 2"},
	)

	// Prints:
	//
	// component=componentNameTest output=console 2 level=warn timestamp=2021-08-19T11:48:34-07:00 message=contentTest 1=2
	// component=componentNameTest output=console 1 level=info timestamp=2021-08-19T11:48:34-07:00 message=contentTest 1=2
}

Output:
Example (PrintNewLine)

PrintNewLine example. 

package main

import (
	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	// Creates logger, and name it.
	l := sypl.New(shared.DefaultComponentNameOutput, output.Console(level.Info))

	l.Infoln(shared.DefaultContentOutput)
	l.PrintNewLine()
	l.Infoln(shared.DefaultContentOutput)

}

Output:

contentTest

contentTest
Example (PrintOnlyIfTagged)

PrintOnlyIfTagged output example. 

package main

import (
	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/processor"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	// Creates logger, and name it.
	sypl.NewDefault(shared.DefaultComponentNameOutput, level.Trace, processor.PrintOnlyIfTagged("testTag")).
		Infoln(shared.DefaultContentOutput).
		PrintlnWithOptions(
			level.Info,
			shared.DefaultContentOutput,
			sypl.WithTags("testTag"),
		)

	// Prints:
	//
	// component=componentNameTest output=console level=info timestamp=2021-08-17T19:19:57-07:00 message=contentTest
}

Output:
Example (PrintPretty)

PrintPretty example. 

package main

import (
	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
)

func main() {
	type TestType struct {
		Key1 string
		Key2 int
	}

	sypl.New("Testing Logger", output.Console(level.Info)).PrintPretty(level.Info, &TestType{
		Key1: "text",
		Key2: 12,
	})

}

Output:

{
	"Key1": "text",
	"Key2": 12
}
Example (PrintWithOptions)

printWithOptions demonstrates `sypl` flexibility. `Options` enhances the usual `PrintX` methods allowing to specify flags, and tags. 

package main

import (
	"fmt"
	"strings"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/message"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/processor"
	"github.com/thalesfsp/sypl/safebuffer"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	// Creates logger, and name it.
	testingLogger := sypl.New("Testing Logger")

	// Creates 3 `Output`s, all called "Console" that will print to `stdout`, and
	// max print level @ `Info`.
	var c1buf safebuffer.Buffer
	Console1ToStdOut := output.New("Buffer 1", level.Info, &c1buf)

	var c2buf safebuffer.Buffer
	Console2ToStdOut := output.New("Buffer 2", level.Info, &c2buf)

	var c3buf safebuffer.Buffer
	Console3ToStdOut := output.New("Buffer 3", level.Info, &c3buf)

	// Creates a `Processor`. It will `prefix` all messages with the Output, and
	// Processor names.
	Prefixer := func() processor.IProcessor {
		return processor.New("Prefixer", func(message message.IMessage) error {
			prefix := fmt.Sprintf("Output: %s Processor: %s Content: ",
				message.GetOutputName(),
				message.GetProcessorName(),
			)

			message.GetContent().SetProcessed(prefix + message.GetContent().GetProcessed())

			return nil
		})
	}

	// Creates a `Processor`. It will `suffix` all messages with the specified
	// `tag`.
	SuffixBasedOnTag := func(tag string) processor.IProcessor {
		return processor.New("SuffixBasedOnTag", func(message message.IMessage) error {
			if message.ContainTag(tag) {
				message.GetContent().SetProcessed(message.GetContent().GetProcessed() + " - My Suffix")
			}

			return nil
		})
	}

	// Adds `Processor`s to `Output`s.
	Console1ToStdOut.AddProcessors(Prefixer(), SuffixBasedOnTag("SuffixIt"))
	Console2ToStdOut.AddProcessors(Prefixer(), SuffixBasedOnTag("SuffixIt"))
	Console3ToStdOut.AddProcessors(Prefixer(), SuffixBasedOnTag("SuffixIt"))

	// Adds all `Output`s to logger.
	testingLogger.AddOutputs(Console1ToStdOut, Console2ToStdOut, Console3ToStdOut)

	// Prints with prefix, without suffix.
	testingLogger.Print(level.Info, shared.DefaultContentOutput)

	fmt.Println(strings.EqualFold(c1buf.String(), "Output: Buffer 1 Processor: Prefixer Content: contentTest"))
	fmt.Println(strings.EqualFold(c2buf.String(), "Output: Buffer 2 Processor: Prefixer Content: contentTest"))
	fmt.Println(strings.EqualFold(c3buf.String(), "Output: Buffer 3 Processor: Prefixer Content: contentTest"))

	c1buf.Reset()
	c2buf.Reset()
	c3buf.Reset()

	// Prints with prefix, and suffix.
	testingLogger.PrintWithOptions(
		level.Info,
		shared.DefaultContentOutput,
		sypl.WithOutputsNames("Buffer 1"),
		sypl.WithProcessorsNames("Prefixer", "SuffixBasedOnTag"),
		sypl.WithTags("SuffixIt"),
	)

	fmt.Println(strings.EqualFold(c1buf.String(), "Output: Buffer 1 Processor: Prefixer Content: contentTest - My Suffix"))

}

Output:

true
true
true
true
Example (SerrorX)

Serror{f|lnf|ln} example. 

package main

import (
	"errors"
	"fmt"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	// Creates logger, and name it.
	testingLogger := sypl.New("Testing Logger", output.Console(level.Info))

	sErrorResult := testingLogger.Serror(shared.DefaultContentOutput)

	errExample := errors.New("Failed to reach something")
	sErrorfResult := testingLogger.Serrorf("Failed to do something, %s", errExample)
	sErrorlnfResult := testingLogger.Serrorlnf("Failed to do something, %s", errExample)
	sErrorlnResult := testingLogger.Serrorln(shared.DefaultContentOutput)

	fmt.Print(
		sErrorResult.Error() == shared.DefaultContentOutput,
		sErrorfResult.Error() == "Failed to do something, Failed to reach something",
		sErrorlnfResult.Error() == "Failed to do something, Failed to reach something"+"\n",
		sErrorlnResult.Error() == shared.DefaultContentOutput+"\n",
	)

}

Output:

contentTestFailed to do something, Failed to reach somethingFailed to do something, Failed to reach something
contentTest
true true true true
Example (StdErrOutputExample)

StdErr output example. 

package main

import (
	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	// Creates logger, and name it.
	sypl.New(shared.DefaultComponentNameOutput, output.StdErr()).
		Infoln(shared.DefaultContentOutput).
		Errorln(shared.DefaultContentOutput)

	// Prints:
	//
	// contentTest
}

Output:
Example (Tagger)

Tagger processor. 

package main

import (
	"fmt"
	"strings"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/formatter"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/processor"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	buf, o := output.SafeBuffer(level.Info, processor.Tagger("a", "b"))

	o.SetFormatter(formatter.Text())

	// Creates logger, and name it.
	sypl.New(shared.DefaultComponentNameOutput, o).Infoln(shared.DefaultContentOutput)

	fmt.Print(strings.Contains(buf.String(), "tags=[a, b]"))

}

Output:

true
Example (TextFormatter)

Text formatter example. 

package main

import (
	"fmt"
	"strings"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/fields"
	"github.com/thalesfsp/sypl/formatter"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	buf, o := output.SafeBuffer(level.Info)
	o.SetFormatter(formatter.Text())

	// Creates logger, and name it.
	sypl.New(shared.DefaultComponentNameOutput).
		AddOutputs(o).
		PrintlnWithOptions(
			level.Info,
			shared.DefaultContentOutput,
			sypl.WithFields(fields.Fields{
				"field1": "value1",
				"field2": "value2",
				"field3": "value3",
			}),
		)

	s := buf.String()

	fmt.Print(
		strings.Contains(s, shared.DefaultContentOutput),
		strings.Contains(s, "field1=value1"),
		strings.Contains(s, "field2=value2"),
		strings.Contains(s, "field3=value3"),
		strings.Contains(s, "component="),
		strings.Contains(s, "level="),
		strings.Contains(s, "timestamp="),
	)

	// Prints:
	//
	// component=componentNameTest level=info field1=value1 field2=value2 field3=value3 timestamp=2021-08-10T22:50:36-07:00

}

Output:

true true true true true true true
Example (UpdateOutputsMaxLevel)

Updating outputs' max levels example. 

package main

import (
	"fmt"
	"os"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	// Creates logger, and name it.
	l := sypl.New(shared.DefaultComponentNameOutput).AddOutputs(
		output.New("Console 1", level.Info, os.Stdout),
		output.New("Console 2", level.Debug, os.Stdout),
		output.New("Console 3", level.Trace, os.Stdout),
	)

	l.PrintlnWithOptions(
		level.Info,
		fmt.Sprint(l.GetMaxLevel()),
		sypl.WithOutputsNames("Console 1"),
	)

	l.SetMaxLevel(level.Info)

	l.PrintlnWithOptions(
		level.Info,
		fmt.Sprint(l.GetMaxLevel()),
		sypl.WithOutputsNames("Console 1"),
	)

}

Output:

map[Console 1:info Console 2:debug Console 3:trace]
map[Console 1:info Console 2:info Console 3:info]
Example (WithID_option)

WithID option. 

package main

import (
	"fmt"
	"strings"

	"github.com/thalesfsp/sypl"
	"github.com/thalesfsp/sypl/formatter"
	"github.com/thalesfsp/sypl/level"
	"github.com/thalesfsp/sypl/output"
	"github.com/thalesfsp/sypl/shared"
)

func main() {
	buf, o := output.SafeBuffer(level.Trace)

	o.SetFormatter(formatter.JSON())

	// Creates logger, and name it.
	sypl.New(shared.DefaultComponentNameOutput, o).PrintWithOptions(level.Info, shared.DefaultContentOutput, sypl.WithID("idTest"))

	fmt.Print(strings.Contains(buf.String(), `"id":"idTest"`))

}

Output:

true

func NewDefault 

func NewDefault(name string, maxLevel level.Level, processors ...processor.IProcessor) *Sypl

NewDefault creates a logger that covers most of all needs: - Writes message to `stdout` @ the specified `maxLevel` - Writes error messages only to `stderr` - Default io.Writer level is `none`. Explicitly change that using `SetDefaultIoWriterLevel` to suit your need.

NOTE: `processors` are applied to both outputs.

func (*Sypl) AddOutputs 

func (sypl *Sypl) AddOutputs(outputs ...output.IOutput) ISypl

AddOutputs adds one or more outputs.

func (*Sypl) AnyMaxLevel added in v1.9.15 

func (sypl *Sypl) AnyMaxLevel(l level.Level) bool

AnyMaxLevel returns if any output has the specified `maxLevel`.

func (*Sypl) Breakpoint 

func (sypl *Sypl) Breakpoint(name string, data ...interface{}) ISypl

Breakpoint will stop execution waiting the user press "/n" ("enter") to continue. It helps users doing log-to-console debug strategy. A message with the breakpoint `name`, and PID of the process will be printed using the `debug` level. Arbitrary `data` can optionally be set - if set, it'll be printed. Errors are printed using the `error` level. Set logging level to `trace` for more.

func (*Sypl) Debug 

func (sypl *Sypl) Debug(args ...interface{}) ISypl

Debug prints @ the Debug level.

func (*Sypl) Debugf 

func (sypl *Sypl) Debugf(format string, args ...interface{}) ISypl

Debugf prints according with the specified format @ the Debug level.

func (*Sypl) Debugln 

func (sypl *Sypl) Debugln(args ...interface{}) ISypl

Debugln prints, also adding a new line to the end @ the Debug level.

func (*Sypl) Debuglnf 

func (sypl *Sypl) Debuglnf(format string, args ...interface{}) ISypl

Debuglnf prints according with the specified format @ the Debug level, also adding a new line to the end.

func (*Sypl) Error 

func (sypl *Sypl) Error(args ...interface{}) ISypl

Error prints @ the Error level.

func (*Sypl) Errorf 

func (sypl *Sypl) Errorf(format string, args ...interface{}) ISypl

Errorf prints according with the format @ the Error level.

func (*Sypl) Errorln 

func (sypl *Sypl) Errorln(args ...interface{}) ISypl

Errorln prints, also adding a new line to the end @ the Error level.

func (*Sypl) Errorlnf 

func (sypl *Sypl) Errorlnf(format string, args ...interface{}) ISypl

Errorlnf prints according with the format @ the Error level, also adding a new line to the end.

func (*Sypl) Fatal 

func (sypl *Sypl) Fatal(args ...interface{}) ISypl

Fatal prints, and exit with os.Exit(1).

func (*Sypl) Fatalf 

func (sypl *Sypl) Fatalf(format string, args ...interface{}) ISypl

Fatalf prints according with the format, and exit with os.Exit(1).

func (*Sypl) Fatalln 

func (sypl *Sypl) Fatalln(args ...interface{}) ISypl

Fatalln prints, also adding a new line and the end, and exit with os.Exit(1).

func (*Sypl) Fatallnf 

func (sypl *Sypl) Fatallnf(format string, args ...interface{}) ISypl

Fatallnf prints according with the format, also adding a new line to the end, and exit with os.Exit(1).

func (*Sypl) GetDefaultIoWriterLevel 

func (sypl *Sypl) GetDefaultIoWriterLevel() level.Level

GetDefaultIoWriterLevel returns the sypl status.

func (*Sypl) GetFields 

func (sypl *Sypl) GetFields() fields.Fields

GetFields returns the global structured fields.

func (*Sypl) GetMaxLevel 

func (sypl *Sypl) GetMaxLevel() map[string]level.Level

GetMaxLevel returns the `maxLevel` of all outputs.

func (*Sypl) GetName 

func (sypl *Sypl) GetName() string

GetName returns the sypl Name.

func (*Sypl) GetOutput 

func (sypl *Sypl) GetOutput(name string) output.IOutput

GetOutput returns the registered output by its name. If not found, will be nil.

func (*Sypl) GetOutputs 

func (sypl *Sypl) GetOutputs() []output.IOutput

GetOutputs returns registered outputs.

func (*Sypl) GetOutputsNames 

func (sypl *Sypl) GetOutputsNames() []string

GetOutputsNames returns the names of the registered outputs.

func (*Sypl) GetStatus 

func (sypl *Sypl) GetStatus() status.Status

GetStatus returns the sypl status.

func (*Sypl) GetTags added in v1.7.2 

func (sypl *Sypl) GetTags() []string

GetTags returns the global tags.

func (*Sypl) Info 

func (sypl *Sypl) Info(args ...interface{}) ISypl

Info prints @ the Info level.

func (*Sypl) Infof 

func (sypl *Sypl) Infof(format string, args ...interface{}) ISypl

Infof prints according with the specified format @ the Info level.

func (*Sypl) Infoln 

func (sypl *Sypl) Infoln(args ...interface{}) ISypl

Infoln prints, also adding a new line to the end @ the Info level.

func (*Sypl) Infolnf 

func (sypl *Sypl) Infolnf(format string, args ...interface{}) ISypl

Infolnf prints according with the specified format @ the Info level, also adding a new line to the end.

func (*Sypl) New 

func (sypl *Sypl) New(name string) *Sypl

New creates a child logger. The child logger is an accurate, efficient and shallow copy of the parent logger. Changes to internals, such as the state of outputs, and processors, are reflected cross all other loggers.

func (*Sypl) Print 

func (sypl *Sypl) Print(l level.Level, args ...interface{}) ISypl

Print just prints.

func (*Sypl) PrintMessage 

func (sypl *Sypl) PrintMessage(messages ...message.IMessage) ISypl

PrintMessage prints messages. It's a powerful option because it gives full-control over the message. Use `New` to create the message. it gives full-control over the message. Use `New` to create the message.

func (*Sypl) PrintMessagesToOutputs 

func (sypl *Sypl) PrintMessagesToOutputs(messagesToOutputs ...MessageToOutput) ISypl

PrintMessagesToOutputs allows you to concurrently print messages, each one, at the specified level and to the specified output.

NOTE: If the named output doesn't exits, the message will not be printed.

func (*Sypl) PrintMessagesToOutputsWithOptions 

func (sypl *Sypl) PrintMessagesToOutputsWithOptions(
	o *options.Options,
	messagesToOutputs ...MessageToOutput,
) ISypl

PrintMessagesToOutputsWithOptions allows you to concurrently print messages, each one, at the specified level and to the specified output, with options.

NOTE: If the named output doesn't exits, the message will not be printed.

func (*Sypl) PrintNewLine 

func (sypl *Sypl) PrintNewLine() ISypl

PrintNewLine prints a new line. It always print, independent of the level, and without any processing.

func (*Sypl) PrintPretty 

func (sypl *Sypl) PrintPretty(l level.Level, data interface{}) ISypl

PrintPretty prints data structures as JSON text.

Notes: - Only exported fields of the data structure will be printed. - Message isn't processed.

func (*Sypl) PrintWithOptions 

func (sypl *Sypl) PrintWithOptions(l level.Level, ct string, o ...OptionFunc) ISypl

PrintWithOptions is a more flexible way of printing, allowing to specify a few message's options in a functional way. For full-control over the message is possible via `PrintMessage`.

func (*Sypl) Printf 

func (sypl *Sypl) Printf(l level.Level, format string, args ...interface{}) ISypl

Printf prints according with the specified format.

func (*Sypl) Println 

func (sypl *Sypl) Println(l level.Level, args ...interface{}) ISypl

Println prints, also adding a new line to the end.

func (*Sypl) PrintlnPretty 

func (sypl *Sypl) PrintlnPretty(l level.Level, data interface{}) ISypl

PrintlnPretty prints data structures as JSON text, also adding a new line to the end.

Notes: - Only exported fields of the data structure will be printed. - Message isn't processed.

func (*Sypl) PrintlnWithOptions 

func (sypl *Sypl) PrintlnWithOptions(l level.Level, ct string, o ...OptionFunc) ISypl

PrintlnWithOptions is a more flexible way of printing, allowing to specify a few message's options in a functional way. For full-control over the message is possible via `PrintMessage`.

func (*Sypl) Printlnf 

func (sypl *Sypl) Printlnf(l level.Level, format string, args ...interface{}) ISypl

Printlnf prints according with the specified format, also adding a new line to the end.

func (*Sypl) Serror 

func (sypl *Sypl) Serror(args ...interface{}) error

Serror prints like Error, and returns an error with the non-processed content.

func (*Sypl) Serrorf 

func (sypl *Sypl) Serrorf(format string, args ...interface{}) error

Serrorf prints like Errorf, and returns an error with the non-processed content.

func (*Sypl) Serrorln 

func (sypl *Sypl) Serrorln(args ...interface{}) error

Serrorln prints like Errorln, and returns an error with the non-processed content.

func (*Sypl) Serrorlnf 

func (sypl *Sypl) Serrorlnf(format string, args ...interface{}) error

Serrorlnf prints like Errorlnf, and returns an error with the non-processed content.

func (*Sypl) SetDefaultIoWriterLevel 

func (sypl *Sypl) SetDefaultIoWriterLevel(l level.Level)

SetDefaultIoWriterLevel sets the default io.Writer level.

func (*Sypl) SetFields 

func (sypl *Sypl) SetFields(fields fields.Fields) ISypl

SetFields sets the global structured fields.

func (*Sypl) SetMaxLevel 

func (sypl *Sypl) SetMaxLevel(l level.Level) ISypl

SetMaxLevel sets the `maxLevel` of all outputs.

func (*Sypl) SetName 

func (sypl *Sypl) SetName(name string)

SetName sets the sypl Name.

func (*Sypl) SetOutputs 

func (sypl *Sypl) SetOutputs(outputs ...output.IOutput) ISypl

SetOutputs sets one or more outputs. Use to update output(s).

func (*Sypl) SetStatus 

func (sypl *Sypl) SetStatus(s status.Status)

SetStatus sets the sypl status.

func (*Sypl) SetTags added in v1.7.2 

func (sypl *Sypl) SetTags(tags ...string) ISypl

SetTags adds the global tags.

func (Sypl) String 

func (sypl Sypl) String() string

String interface implementation.

func (*Sypl) Trace 

func (sypl *Sypl) Trace(args ...interface{}) ISypl

Trace prints @ the Trace level.

func (*Sypl) Tracef 

func (sypl *Sypl) Tracef(format string, args ...interface{}) ISypl

Tracef prints according with the specified format @ the Trace level.

func (*Sypl) Traceln 

func (sypl *Sypl) Traceln(args ...interface{}) ISypl

Traceln prints, also adding a new line to the end @ the Trace level.

func (*Sypl) Tracelnf 

func (sypl *Sypl) Tracelnf(format string, args ...interface{}) ISypl

Tracelnf prints according with the specified format @ the Trace level, also adding a new line to the end.

func (*Sypl) Warn 

func (sypl *Sypl) Warn(args ...interface{}) ISypl

Warn prints @ the Warn level.

func (*Sypl) Warnf 

func (sypl *Sypl) Warnf(format string, args ...interface{}) ISypl

Warnf prints according with the specified format @ the Warn level.

func (*Sypl) Warnln 

func (sypl *Sypl) Warnln(args ...interface{}) ISypl

Warnln prints, also adding a new line to the end @ the Warn level.

func (*Sypl) Warnlnf 

func (sypl *Sypl) Warnlnf(format string, args ...interface{}) ISypl

Warnlnf prints according with the specified format @ the Warn level, also adding a new line to the end.

func (*Sypl) Write 

func (sypl *Sypl) Write(p []byte) (int, error)

Writer implements the io.Writer interface. Message level will be the one set via `SetIoWriterLevel`, default is `none`. It always returns `0, nil`.

NOTE: This is a convenient method, if it doesn't fits your need, just implement the way you need.

Source Files

View all Source files

Directories

Path Synopsis
Package elasticsearch provides a client for the Elasticsearch.
 Package elasticsearch provides a client for the Elasticsearch.
internal
builtin
Package log implements a simple logging package.
 Package log implements a simple logging package.
Package processor provides the building blocks to create processors, which are used to process messages before they are printed.
 Package processor provides the building blocks to create processors, which are used to process messages before they are printed.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.