1598292900
In computing paradigm, a log file is a file that records either events that occur in the operating system or other software runs or messages between the different users of communication software. Logging is an act of keeping a log. In the simplest case, messages are written to the single log file. Let’s deep dive into Golang Log Example.
Large corporations that depend on the distributed systems often write their applications in Go to take advantage of the concurrency features like channels and goroutines (e.g., Heroku, Basecamp).
If you are responsible for building or supporting the Go applications, a well-considered logging strategy can help you to understand user behavior, localize errors, and monitor the performance of your applications.
#golang #go
1599854400
Go announced Go 1.15 version on 11 Aug 2020. Highlighted updates and features include Substantial improvements to the Go linker, Improved allocation for small objects at high core counts, X.509 CommonName deprecation, GOPROXY supports skipping proxies that return errors, New embedded tzdata package, Several Core Library improvements and more.
As Go promise for maintaining backward compatibility. After upgrading to the latest Go 1.15 version, almost all existing Golang applications or programs continue to compile and run as older Golang version.
#go #golang #go 1.15 #go features #go improvement #go package #go new features
1626495660
Send an email with Golang using a popular package Gomail.
Gomail is a simple and efficient package to send emails. It is well tested and documented.
Gomail can only send emails using an SMTP server. But the API is flexible and it is easy to implement other methods for sending emails using a local Postfix, an API, etc.
Install Gomail: go get gopkg.in/gomail.v2
#golang #Gomail #emailGolang #GolangEMail
#golang #go mail package #go
1649697300
ozzo-log
ozzo-log is a Go package providing enhanced logging support for Go programs. It has the following features:
Go 1.2 or above.
Run the following command to install the package:
go get github.com/go-ozzo/ozzo-log
The following code snippet shows how you can use this package.
package main
import (
"github.com/go-ozzo/ozzo-log"
)
func main() {
// creates the root logger
logger := log.NewLogger()
// adds a console target and a file target
t1 := log.NewConsoleTarget()
t2 := log.NewFileTarget()
t2.FileName = "app.log"
t2.MaxLevel = log.LevelError
logger.Targets = append(logger.Targets, t1, t2)
logger.Open()
defer logger.Close()
// calls log methods to log various log messages
logger.Error("plain text error")
logger.Error("error with format: %v", true)
logger.Debug("some debug info")
// customizes log category
l := logger.GetLogger("app.services")
l.Info("some info")
l.Warning("some warning")
...
}
A logger provides various log methods that can be called by application code to record messages of various severity levels.
A target filters log messages by their severity levels and message categories and processes the filtered messages in various ways, such as saving them in files, sending them in emails, etc.
A logger can be equipped with multiple targets each with different filtering conditions.
The following targets are included in the ozzo-log package.
ConsoleTarget
: displays filtered messages to console windowFileTarget
: saves filtered messages in a file (supporting file rotating)NetworkTarget
: sends filtered messages to an address on a networkMailTarget
: sends filtered messages in emailsYou can create a logger, configure its targets, and start to use logger with the following code:
// creates the root logger
logger := log.NewLogger()
logger.Targets = append(logger.Targets, target1, target2, ...)
logger.Open()
...calling log methods...
logger.Close()
You can log a message of a particular severity level (following the RFC5424 standard) by calling one of the following methods of the Logger
struct:
Emergency()
: the system is unusable.Alert()
: action must be taken immediately.Critical()
: critical conditions.Error()
: error conditions.Warning()
: warning conditions.Notice()
: normal but significant conditions.Info()
: informational purpose.Debug()
: debugging purpose.Each log message is associated with a category which can be used to group messages. For example, you may use the same category for messages logged by the same Go package. This will allow you to selectively send messages to different targets.
When you call log.NewLogger()
, a root logger is returned which logs messages using the category named as app
. To log messages with a different category, call the GetLogger()
method of the root logger or a parent logger to get a child logger and then call its log methods:
logger := log.NewLogger()
// the message is of category "app"
logger.Error("...")
l1 := logger.GetLogger("system")
// the message is of category "system"
l1.Error("...")
l2 := l1.GetLogger("app.models")
// the message is of category "app.models"
l2.Error("...")
By default, each log message takes this format when being sent to different targets:
2015-10-22T08:39:28-04:00 [Error][app.models] something is wrong
...call stack (if enabled)...
You may customize the message format by specifying your own message formatter when calling Logger.GetLogger()
. For example,
logger := log.NewLogger()
logger = logger.GetLogger("app", func (l *Logger, e *Entry) string {
return fmt.Sprintf("%v [%v][%v] %v%v", e.Time.Format(time.RFC822Z), e.Level, e.Category, e.Message, e.CallStack)
})
By setting Logger.CallStackDepth
as a positive number, it is possible to record call stack information for each log method call. You may further configure Logger.CallStackFilter
so that only call stack frames containing the specified substring will be recorded. For example,
logger := log.NewLogger()
// record call stacks containing "myapp/src" up to 5 frames per log message
logger.CallStackDepth = 5
logger.CallStackFilter = "myapp/src"
By default, messages of all severity levels will be recorded. You may customize Logger.MaxLevel
to change this behavior. For example,
logger := log.NewLogger()
// only record messages between Emergency and Warning levels
logger.MaxLevel = log.LevelWarning
Besides filtering messages at the logger level, a finer grained message filtering can be done at target level. For each target, you can specify its MaxLevel
similar to that with the logger; you can also specify which categories of the messages the target should handle. For example,
target := log.NewConsoleTarget()
// handle messages between Emergency and Info levels
target.MaxLevel = log.LevelInfo
// handle messages of categories which start with "system.db." or "app."
target.Categories = []string{"system.db.*", "app.*"}
When an application is deployed for production, a common need is to allow changing the logging configuration of the application without recompiling its source code. ozzo-log is designed with this in mind.
For example, you can use a JSON file to specify how the application and its logger should be configured:
{
"Logger": {
"Targets": [
{
"type": "ConsoleTarget",
},
{
"type": "FileTarget",
"FileName": "app.log",
"MaxLevel": 4 // Warning or above
}
]
}
}
Assuming the JSON file is app.json
, in your application code you can use the ozzo-config
package to load the JSON file and configure the logger used by the application:
package main
import (
"github.com/go-ozzo/ozzo-config"
"github.com/go-ozzo/ozzo-log"
)
func main() {
c := config.New()
c.Load("app.json")
// register the target types to allow configuring Logger.Targets.
c.Register("ConsoleTarget", log.NewConsoleTarget)
c.Register("FileTarget", log.NewFileTarget)
logger := log.NewLogger()
if err := c.Configure(logger, "Logger"); err != nil {
panic(err)
}
}
To change the logger configuration, simply modify the JSON file without recompiling the Go source files.
Other languages
Author: Go-ozzo
Source Code: https://github.com/go-ozzo/ozzo-log
License: MIT License
1598292900
In computing paradigm, a log file is a file that records either events that occur in the operating system or other software runs or messages between the different users of communication software. Logging is an act of keeping a log. In the simplest case, messages are written to the single log file. Let’s deep dive into Golang Log Example.
Large corporations that depend on the distributed systems often write their applications in Go to take advantage of the concurrency features like channels and goroutines (e.g., Heroku, Basecamp).
If you are responsible for building or supporting the Go applications, a well-considered logging strategy can help you to understand user behavior, localize errors, and monitor the performance of your applications.
#golang #go
1649555340
Package log implements a simple structured logging API inspired by Logrus, designed with centralization in mind.
Example using the Apex Logs handler.
package main
import (
"errors"
"time"
"github.com/apex/log"
)
func main() {
ctx := log.WithFields(log.Fields{
"file": "something.png",
"type": "image/png",
"user": "tobi",
})
for range time.Tick(time.Millisecond * 200) {
ctx.Info("upload")
ctx.Info("upload complete")
ctx.Warn("upload retry")
ctx.WithError(errors.New("unauthorized")).Error("upload failed")
ctx.Errorf("failed to upload %s", "img.png")
}
}
Read more on Medium.
Author: Apex
Source Code: https://github.com/apex/log
License: MIT License