sypl

package module
v1.5.14 Latest Latest
Warning

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

 Go to latest Published: Aug 9, 2022 License: MIT Imports: 20 Imported by: 3

README

sypl

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/saucelabs/sypl

Specific version

Example: $ go get github.com/saucelabs/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?")

Functions

func RedirectStdLog added in v1.5.12 

func RedirectStdLog(sypl *Sypl) func()

RedirectStdLog redirects output from the standard library's package-global logger to the supplied logger at level.Info. Since zap already handles caller annotations, timestamps, etc., it automatically disables the standard library's annotations and prefixing.

It returns a function to restore the original prefix and flags and reset the standard library's output to os.Stderr.

func RedirectStdLogAt added in v1.5.12 

func RedirectStdLogAt(sypl *Sypl, lvl level.Level) (func(), error)

RedirectStdLogAt redirects output from the standard library's package-global logger to the supplied logger at the specified level. Since sypl already handles caller annotations, timestamps, etc., it automatically disables the standard library's annotations and prefixing.

It returns a function to restore the original prefix and flags and reset the standard library's output to os.Stderr.

Types

type IBasePrinter added in v1.3.2 

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. For full-control over the message is possible
	// via `PrintMessage`.
	PrintWithOptions(o *options.Options, l level.Level, args ...interface{}) ISypl

	// PrintfWithOptions prints according with the specified format. It's a more
	// flexible way of printing, allowing to specify a few message's options.
	// For full-control over the message is possible via `PrintMessage`.
	PrintfWithOptions(o *options.Options, l level.Level, format string, args ...interface{}) ISypl

	// PrintfWithOptions prints according with the specified format, also adding
	// a new line to the end. It's a more flexible way of printing, allowing to
	// specify a few message's options. For full-control over the message is
	// possible via `PrintMessage`.
	PrintlnfWithOptions(o *options.Options, l level.Level, format string, args ...interface{}) ISypl

	// PrintfWithOptions prints, also adding a new line to the end. It's a more
	// flexible way of printing, allowing to specify a few message's options.
	// For full-control over the message is possible via `PrintMessage`.
	PrintlnWithOptions(o *options.Options, l level.Level, args ...interface{}) ISypl
}

IBasePrinter specifies the foundation for other printers.

type IBasicPrinter added in v1.3.2 

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

	// Printlnf prints according with the specified format, also adding a new
	// line to the end.
	Printlnf(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 added in v1.3.2 

type IConvenientPrinter interface {
	// 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 added in v1.3.2 

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 added in v1.3.2 

type IPrinters interface {
	IBasePrinter
	IBasicPrinter
	IConvenientPrinter
	ILeveledPrinter
}

IPrinters is all available printers.

type ISypl added in v1.3.2 

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

	// 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 added in v1.3.2 

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 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 an example of creating and setting up a `sypl` logger chaining. It writes to both `stdout` and `stderr`. 

package main

import (
	"os"

	"github.com/saucelabs/sypl"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/message"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/sypl/processor"
	"github.com/saucelabs/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 an example of creating, and setting up a `sypl` logger using built-in `Output`, and `Processor` chaining. It writes to `stdout`, and `stderr`. 

package main

import (
	"github.com/saucelabs/sypl"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/sypl/processor"
	"github.com/saucelabs/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/saucelabs/sypl"
	"github.com/saucelabs/sypl/formatter"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/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/saucelabs/sypl"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/sypl/shared"
)

func main() {
	// From any SYPL logger, bump all max levels to `info`
	// From any SYPL logger havong 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.DebugEnvVar, "info,console:debug,pod:console:trace,pv:o1:trace")
	defer os.Unsetenv(shared.DebugEnvVar)

	// 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/saucelabs/sypl"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/sypl/processor"
	"github.com/saucelabs/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/saucelabs/sypl"
	"github.com/saucelabs/sypl/flag"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/options"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/sypl/processor"
	"github.com/saucelabs/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(&options.Options{
			Flag: flag.Force,
		}, level.Debug, shared.DefaultContentOutput).

		// Message will be processed, but not printed.
		PrintlnWithOptions(&options.Options{
			Flag: flag.Mute,
		}, level.Info, shared.DefaultContentOutput).

		// Message will not be processed, but printed.
		PrintlnWithOptions(&options.Options{
			Flag: flag.Skip,
		}, level.Info, shared.DefaultContentOutput).

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

		// SkipAndForce message will not be processed, but will be printed
		// independent of `Level` restrictions.
		PrintlnWithOptions(&options.Options{
			Flag: flag.SkipAndForce,
		}, level.Debug, shared.DefaultContentOutput).

		// Message will not be processed, neither printed.
		PrintlnWithOptions(&options.Options{
			Flag: flag.SkipAndMute,
		}, level.Debug, shared.DefaultContentOutput)

}

Output:

My Prefix - contentTest
contentTest
contentTest
Example (GlobalFields)

Global fields example. 

package main

import (
	"fmt"
	"strings"

	"github.com/saucelabs/sypl"
	"github.com/saucelabs/sypl/fields"
	"github.com/saucelabs/sypl/formatter"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/options"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/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.PrintlnWithOptions(&options.Options{
		Fields: fields.Fields{"a": 2, "b": 3},
	}, level.Info, shared.DefaultContentOutput) // 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 (InlineUsingBuiltin)

inlineUsingBuiltin same as `ChainedUsingBuiltin` but using inline form. 

package main

import (
	"github.com/saucelabs/sypl"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/sypl/processor"
	"github.com/saucelabs/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/saucelabs/sypl"
	"github.com/saucelabs/sypl/formatter"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/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/saucelabs/sypl"
	"github.com/saucelabs/sypl/fields"
	"github.com/saucelabs/sypl/formatter"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/options"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/sypl/shared"
)

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

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

	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/saucelabs/sypl"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/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/saucelabs/sypl"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/message"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/sypl/processor"
	"github.com/saucelabs/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/saucelabs/sypl"
	"github.com/saucelabs/sypl/formatter"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/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/saucelabs/sypl"
	"github.com/saucelabs/sypl/fields"
	"github.com/saucelabs/sypl/formatter"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/options"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/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/saucelabs/sypl"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/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/saucelabs/sypl"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/options"
	"github.com/saucelabs/sypl/processor"
	"github.com/saucelabs/sypl/shared"
)

func main() {
	// Creates logger, and name it.
	sypl.NewDefault(shared.DefaultComponentNameOutput, level.Trace, processor.PrintOnlyIfTagged("testTag")).
		Infoln(shared.DefaultContentOutput).
		PrintlnWithOptions(&options.Options{
			Tags: []string{"testTag"},
		}, level.Info, shared.DefaultContentOutput)

	// 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/saucelabs/sypl"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/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/saucelabs/sypl"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/message"
	"github.com/saucelabs/sypl/options"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/sypl/processor"
	"github.com/saucelabs/sypl/safebuffer"
	"github.com/saucelabs/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(&options.Options{
		OutputsNames:    []string{"Buffer 1"},
		ProcessorsNames: []string{"Prefixer", "SuffixBasedOnTag"},
		Tags:            []string{"SuffixIt"},
	}, level.Info, shared.DefaultContentOutput)

	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/saucelabs/sypl"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/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/saucelabs/sypl"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/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 (TextFormatter)

Text formatter example. 

package main

import (
	"fmt"
	"strings"

	"github.com/saucelabs/sypl"
	"github.com/saucelabs/sypl/fields"
	"github.com/saucelabs/sypl/formatter"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/options"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/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(&options.Options{
			Fields: fields.Fields{
				"field1": "value1",
				"field2": "value2",
				"field3": "value3",
			},
		}, level.Info, shared.DefaultContentOutput)

	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 (
	"os"

	"github.com/saucelabs/sypl"
	"github.com/saucelabs/sypl/level"
	"github.com/saucelabs/sypl/options"
	"github.com/saucelabs/sypl/output"
	"github.com/saucelabs/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(&options.Options{
		OutputsNames: []string{"Console 1"},
	}, level.Info, l.GetMaxLevel())

	l.SetMaxLevel(level.Info)

	l.PrintlnWithOptions(&options.Options{
		OutputsNames: []string{"Console 1"},
	}, level.Info, l.GetMaxLevel())

}

Output:

map[Console 1:info Console 2:debug Console 3:trace]
map[Console 1:info Console 2:info Console 3:info]

func NewDefault added in v1.3.6 

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 added in v1.3.2 

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

AddOutputs adds one or more outputs.

func (*Sypl) Breakpoint added in v1.5.6 

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 added in v1.2.0 

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 added in v1.2.0 

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 added in v1.2.0 

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 added in v1.5.9 

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

GetDefaultIoWriterLevel returns the sypl status.

func (*Sypl) GetFields added in v1.5.0 

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

GetFields returns the structured fields.

func (*Sypl) GetMaxLevel added in v1.3.8 

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

GetMaxLevel returns the `maxLevel` of all outputs.

func (*Sypl) GetName added in v1.1.0 

func (sypl *Sypl) GetName() string

GetName returns the sypl Name.

func (*Sypl) GetOutput added in v1.1.0 

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 added in v1.1.0 

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

GetOutputs returns registered outputs.

func (*Sypl) GetOutputsNames added in v1.3.2 

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

GetOutputsNames returns the names of the registered outputs.

func (*Sypl) GetStatus added in v1.3.2 

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

GetStatus returns the sypl status.

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 added in v1.2.0 

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 added in v1.3.2 

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 added in v1.3.2 

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 added in v1.3.2 

func (sypl *Sypl) PrintMessagesToOutputs(messagesToOutputs ...MessageToOutput) 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.

func (*Sypl) PrintMessagesToOutputsWithOptions added in v1.4.2 

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 added in v1.4.4 

func (sypl *Sypl) PrintNewLine() ISypl

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

func (*Sypl) PrintPretty added in v1.1.1 

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 added in v1.1.0 

func (sypl *Sypl) PrintWithOptions(o *options.Options, l level.Level, args ...interface{}) ISypl

PrintWithOptions is a more flexible way of printing, allowing to specify a few message's options. 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) PrintfWithOptions added in v1.1.0 

func (sypl *Sypl) PrintfWithOptions(o *options.Options, l level.Level, format string, args ...interface{}) ISypl

PrintfWithOptions prints according with the specified format. It's a more flexible way of printing, allowing to specify a few message's options. For full-control over the message is possible via `PrintMessage`.

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 added in v1.1.1 

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 added in v1.1.0 

func (sypl *Sypl) PrintlnWithOptions(o *options.Options, l level.Level, args ...interface{}) ISypl

PrintfWithOptions prints, also adding a new line to the end. It's a more flexible way of printing, allowing to specify a few message's options. For full-control over the message is possible via `PrintMessage`.

func (*Sypl) Printlnf added in v1.2.0 

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) PrintlnfWithOptions added in v1.3.2 

func (sypl *Sypl) PrintlnfWithOptions(o *options.Options, l level.Level, format string, args ...interface{}) ISypl

PrintfWithOptions prints according with the specified format, also adding a new line to the end. It's a more flexible way of printing, allowing to specify a few message's options. For full-control over the message is possible via `PrintMessage`.

func (*Sypl) Serror added in v1.2.3 

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

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

func (*Sypl) Serrorf added in v1.2.3 

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 added in v1.2.3 

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

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

func (*Sypl) Serrorlnf added in v1.2.3 

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 added in v1.5.9 

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

SetDefaultIoWriterLevel sets the default io.Writer level.

func (*Sypl) SetFields added in v1.5.0 

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

SetFields sets the structured fields.

func (*Sypl) SetMaxLevel added in v1.3.8 

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

SetMaxLevel sets the `maxLevel` of all outputs.

func (*Sypl) SetName added in v1.3.2 

func (sypl *Sypl) SetName(name string)

SetName sets the sypl Name.

func (*Sypl) SetOutputs added in v1.3.2 

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

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

func (*Sypl) SetStatus added in v1.3.2 

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

SetStatus sets the sypl status.

func (Sypl) String added in v1.3.2 

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 added in v1.2.0 

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 added in v1.2.0 

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 added in v1.5.9 

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, as you would do.

Source Files

View all Source files

Directories

Path Synopsis
internal
builtin
Package log implements a simple logging package.
 Package log implements a simple logging package.

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.