Optimizing Logs Utilizing Logrus to Record Logs to a File
Tags: go, beginners, discuss, webdev
Published: 2023-06-14 07:39:22

## [Logrus](https://github.com/sirupsen/logrus)
is a logging library for Go programming language that simplifies the process of recording logs to a file. It offers a clean and intuitive API, making it easy to implement and customize logging functionalities according to your specific needs. With Logrus, you can improve the efficiency of your logs, making them more organized, informative, and easily manageable.

<img width="100%" style="width:100%" src="https://media.giphy.com/media/3o6Ztk7NosfLVRqcpy/giphy.gif">

```go
package main

import (
  "os"
  "github.com/sirupsen/logrus"
  "errors"
)

// Create a new instance of the logger. You can have any number of instances.
var log = logrus.New()

func init() {
  // Log as JSON instead of the default ASCII formatter.
  log.SetFormatter(&logrus.JSONFormatter{})
  // Only log the debug severity or above.
  log.SetLevel(logrus.DebugLevel)
}

func main() {
  ctx := "LogrusToLogFile" //context

  log.Out = os.Stdout
  // You could set this to any `io.Writer` such as a file
  file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
  if err == nil {
   log.Out = file
  } else {
    log.Info("Failed to log to file, using default stderr")
  }

  //make fake error
  err = errors.New("math: square root of negative number")
  if err != nil {
    log.WithFields(logrus.Fields{
      "ctx": ctx,
    }).Error("Write to file")
  }

}

```

In the given code, we use the Logrus library to log messages to a file, import the necessary packages such as.
- `"os"` for system operations. 
- `"github.com/sirupsen/logrus"` for Logrus
- `"errors"` to define an error.

```go
import (
  "os"
  "github.com/sirupsen/logrus"
  "errors"
)
```

We create a new instance of the logger using `logrus.New()` Then, we set the log formatter to **JSONFormatter** to generate logs in JSON format. SetLevel is used to specify the logging level.

```go
var log = logrus.New()

func init() {
  // Log as JSON instead of the default ASCII formatter.
  log.SetFormatter(&logrus.JSONFormatter{})
  // Only log the debug severity or above.
  log.SetLevel(logrus.DebugLevel)
}
```
> which is set to **debug** level in this example.


```go
 log.Out = os.Stdout
  // You could set this to any `io.Writer` such as a file
  file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
  if err == nil {
   log.Out = file
  } else {
    log.Info("Failed to log to file, using default stderr")
  }
```

In the main function, we perform several configurations for the logger. 
- we set logrus to log messages to os.Stdout as the default output. - we attempt to open the "logrus.log" file to log messages into it. - If successful, we set log.Out to use the file as the log output. - If there is an error, we print an informational message stating that logging to the file failed and fall back to using os.Stderr as the output.

```go
os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
```

Here's the breakdown of the arguments used in the `OpenFile()`

- `logrus.log` is a string representing the file name that will be opened or created. In this example, the file name used is "logrus.log".
- `os.O_CREATE|os.O_WRONLY|os.O_APPEND` is a combination of flags that determine the operations to be performed on the file.
	- `os.O_CREATE` is used to create the file if it doesn't exist.
	- `os.O_WRONLY` is used to open the file in write-only mode.
	- `os.O_APPEND` is used to append data to the file if it already exists.
- `0666`is the file mode that specifies the permissions for the created file. In this example, the mode `0666`allows the user, group, and others to read and write the file.

```go
//make fake error
  err = errors.New("math: square root of negative number")
  if err != nil {
    log.WithFields(logrus.Fields{
      "ctx": ctx,
    }).Error("Write to file")
  }
```

We create a fake error using `errors.New()`. If the error is not nil, we use `logrus.WithFields` to add additional information to the log, in this case, the "ctx" field. Then, we log an error message using `logrus.Error`/ `Error("Write to file")`.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hcavmi306nvlx6k86i0d.png)

You will execute the command go run log_logrus.go to run a Go program called log_logrus.go. This program utilizes the Logrus library to record logs to a file.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/uxuy6x2gyfjijyjm6q3x.png)

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nt2ie5i96w0ev374b0gd.png)


By configuring Logrus to log messages to a file, we can record logs into the "logrus.log" file. This can be helpful for monitoring and analyzing application logs more efficiently.

Overall, the code is a simple example of using Logrus to log messages to a file with appropriate configurations and error handling.

<img width="100%" style="width:100%" src="https://media.giphy.com/media/xonOzxf2M8hNu/giphy.gif">

**In conclusion** optimizing logs is crucial for efficient application development and maintenance. By utilizing Logrus, a powerful logging library for the Go programming language, you can simplify the process of recording logs to a file and enhance the effectiveness of your logging system.

https://github.com/sirupsen/logrus