# Logging

This program demonstrates the use of the standard `log` package and the `log/slog` package (structured logger) in Go. Let me break down the code and provide some explanations:

```go
package main

import (
	"bytes"
	"fmt"
	"log"
	"os"
	"log/slog"
)

func main() {
	// Standard logger usage
	log.Println("standard logger")

	// Modify standard logger flags to include microseconds
	log.SetFlags(log.LstdFlags | log.Lmicroseconds)
	log.Println("with micro")

	// Modify standard logger flags to include file and line
	log.SetFlags(log.LstdFlags | log.Lshortfile)
	log.Println("with file/line")

	// Creating a custom logger (mylog) with a prefix and specific flags
	mylog := log.New(os.Stdout, "my:", log.LstdFlags)
	mylog.Println("from mylog")

	// Changing prefix for the custom logger
	mylog.SetPrefix("ohmy:")
	mylog.Println("from mylog")

	// Creating a logger (buflog) that writes to a buffer
	var buf bytes.Buffer
	buflog := log.New(&buf, "buf:", log.LstdFlags)
	buflog.Println("hello")

	// Printing the content of the buffer
	fmt.Print("from buflog:", buf.String())

	// Using the slog package to create a structured logger (myslog)
	jsonHandler := slog.NewJSONHandler(os.Stderr, nil)
	myslog := slog.New(jsonHandler)

	// Logging messages with additional key-value pairs
	myslog.Info("hi there")
	myslog.Info("hello again", "key", "val", "age", 25)
}
```

#### Output

```
2024/01/25 17:41:04 standard logger
2024/01/25 17:41:04.107521 with micro
2024/01/25 17:41:04 logging.go:20: with file/line
my:2024/01/25 17:41:04 from mylog
ohmy:2024/01/25 17:41:04 from mylog
from buflog:buf:2024/01/25 17:41:04 hello
{"time":"2024-01-25T17:41:04.1080462+05:30","level":"INFO","msg":"hi there"}
{"time":"2024-01-25T17:41:04.1080462+05:30","level":"INFO","msg":"hello again","key":"val","age":25}
```

Explanation:

1. **Standard Logger (`log` package):**
   * The program starts by using the standard logger (`log.Println`) with various log messages.
   * Flags for the standard logger are modified to include microseconds and file/line information.
2. **Custom Logger (`log.New`):**
   * A custom logger (`mylog`) is created using `log.New` with a specific output (`os.Stdout`), prefix ("my:"), and flags.
   * The prefix is later modified to "ohmy:".
3. **Buffered Logger (`log.New` with `bytes.Buffer`):**
   * Another logger (`buflog`) is created that writes log messages to a buffer (`bytes.Buffer`).
   * The content of the buffer is printed to the standard output.
4. **Structured Logger (`log/slog` package):**
   * The `slog` package is used to create a structured logger (`myslog`) with a JSON formatter.
   * Log messages are provided with additional key-value pairs.

You can run the program to observe the different log messages and how they are formatted based on the logger configurations:

```bash
go run main.go
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://ineelhere.gitbook.io/code-with-go/73-logging.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.