reporter.Init(reporter.Config{
    AppName:          "payment-service",
    AppEnv:           "development",
    EnablePublishing: false,
})
defer reporter.Close()

reporter.Init(reporter.Config{
    AppName:          "payment-service",
    AppEnv:           "production",
    EnablePublishing: false,
})
defer reporter.Close()

redisClient := redis.NewClient(&redis.Options{
    Addr: "localhost:6379",
})

if err := redisClient.Ping(ctx).Err(); err != nil {
    return reporter.WrapWithSeverity(err, reporter.SeverityCritical, "Failed to connect to Redis")
}

reporter.SetPublisher(reporter.NewRedisListPublisher(redisClient, "service-alerts"))

func main() {
    reporter.Init(reporter.Config{
        AppName:          "payment-service",
        AppEnv:           "production",
        EnablePublishing: true,
    })
    defer reporter.Close()

    // Example: Handling a fatal database startup failure
    if err := connectDatabase(); err != nil {
        wrappedErr := reporter.AutoWrap(err)
        
        reporter.Flush() // <-- CRITICAL: Wait for the background log to be sent safely
        log.Fatalf("System failed to boot: %v", wrappedErr)
    }
}

`Config` fields:

| Field                      | Required | Description                                                                                                                         |
| -------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| `AppName`                  | No       | Service name included in every report. Defaults to `unknown-service`.                                                               |
| `AppEnv`                   | No       | Runtime environment. Defaults to `development`. `production` makes `Error()` return JSON.                                           |
| `KafkaBrokers`             | Kafka    | Kafka broker list, for example `[]string{"kafka-1:9092", "kafka-2:9092"}`.                                                          |
| `KafkaTopic`               | Kafka    | Kafka topic used for alert messages.                                                                                                |
| `EnablePublishing`         | No       | Enables Kafka publishing when `KafkaBrokers` and `KafkaTopic` are also provided. Defaults to `false`.                               |
| `Publisher`                | No       | Optional publisher, for example `NewRedisListPublisher(...)` or a custom publisher. When provided with `EnablePublishing=true`, it is used instead of Kafka config. |
| `PublishMinSeverity`       | No       | Minimum severity that may be published. Defaults to `danger`, so handled errors such as duplicate data are not sent to Kafka/Redis. |
| `AutoWrapFallbackSeverity` | No       | Severity for `AutoWrap` errors that do not match any known pattern. Defaults to `danger`.                                           |

Publishing is non-blocking. When `EnablePublishing=true` and either `Publisher` or Kafka configuration is complete, the package sends the structured payload in a background goroutine. If publishing fails, the failure is written to `stderr` so the original error is not lost.

Severity values:

| Severity   | Typical Use                                                         | Published by Default |
| ---------- | ------------------------------------------------------------------- | -------------------- |
| `info`     | Handled business/data cases such as duplicate data or not found.    | No                   |
| `warning`  | Recoverable issues that should be watched but do not need alerts.   | No                   |
| `danger`   | Serious application issues, HTTP 500-style failures, logic anomaly. | Yes                  |
| `critical` | Infrastructure outage such as database/API connection failure.      | Yes                  |

Set `PublishMinSeverity` when you want a different alert threshold:

```go
reporter.Init(reporter.Config{
    AppName:            "payment-service",
    AppEnv:             "production",
    EnablePublishing:   true,
    KafkaBrokers:       []string{"kafka-1:9092"},
    KafkaTopic:         "service-alerts",
    PublishMinSeverity: reporter.SeverityCritical,
})

reporter.Init(reporter.Config{
    AppName:                  "payment-service",
    AppEnv:                   "production",
    EnablePublishing:         true,
    KafkaBrokers:             []string{"kafka-1:9092"},
    KafkaTopic:               "service-alerts",
    PublishMinSeverity:       reporter.SeverityDanger,
    AutoWrapFallbackSeverity: reporter.SeverityWarning,
})

reporter.Init(reporter.Config{
    AppName:          os.Getenv("APP_NAME"),
    AppEnv:           os.Getenv("APP_ENV"),
    KafkaBrokers:     strings.Split(os.Getenv("KAFKA_BROKERS"), ","),
    KafkaTopic:       os.Getenv("KAFKA_TOPIC"),
    EnablePublishing: os.Getenv("APP_ENV") == "production",
})

package main

import (
    "errors"

    "github.com/learncodexx/reporter/v2"
)

func main() {
    reporter.Init(reporter.Config{
        AppName: "example-service",
        AppEnv:  "development",
    })
    defer reporter.Close()

    err := doWork()
    if err != nil {
        reporter.AutoWrap(err)
        return
    }
}

func doWork() error {
    return errors.New("connection refused")
}

package main

import "github.com/learncodexx/reporter/v2"

func StartServer() {
    // Log successful milestones without bothering alerting consumers
    reporter.Info("SERVER", "HTTP server smoothly binding to port %d", 8080)
    reporter.Info("DATABASE", "Successfully verified connection handshake with PostgreSQL cluster")
}

err := repository.SaveOrder(order)
if err != nil {
    return reporter.Wrap(err, "Failed to save checkout order after payment was confirmed")
}

if err := checkout(order); err != nil {
    return reporter.WrapHTTPStatus(err, 500, "Checkout handler failed")
}

if err := checkout(order); err != nil {
    return reporter.WrapReport(err, reporter.ReportOptions{
        Description: "Checkout handler failed",
        StatusCode:  500,
        Severity:    reporter.SeverityDanger,
    })
}

package main

import (
    "github.com/learncodexx/reporter/v2"
)

func main() {
    reporter.Init(reporter.Config{
        AppName:          "payment-service",
        AppEnv:           "production",
        KafkaBrokers:     []string{"kafka-1:9092", "kafka-2:9092"},
        KafkaTopic:       "service-alerts",
        EnablePublishing: true,
    })
    defer reporter.Close()

    if err := run(); err != nil {
        reporter.AutoWrap(err)
        return
    }
}

package main

import (
    "github.com/learncodexx/reporter/v2"
    "github.com/redis/go-redis/v9"
)

func main() {
    redisClient := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })
    defer redisClient.Close()

    reporter.Init(reporter.Config{
        AppName:          "payment-service",
        AppEnv:           "production",
        EnablePublishing: true,
        Publisher:        reporter.NewRedisListPublisher(redisClient, "service-alerts"),
    })
    defer reporter.Close()

    if err := run(); err != nil {
        reporter.AutoWrap(err)
        return
    }
}

type Publisher interface {
    Publish(ctx context.Context, report *reporter.CustomError) error
}

type WebhookPublisher struct {
    endpoint string
    client   *http.Client
}

func (p *WebhookPublisher) Publish(ctx context.Context, report *reporter.CustomError) error {
    payload, err := json.Marshal(report)
    if err != nil {
        return err
    }

    req, err := http.NewRequestWithContext(ctx, http.MethodPost, p.endpoint, bytes.NewReader(payload))
    if err != nil {
        return err
    }
    req.Header.Set("Content-Type", "application/json")

    resp, err := p.client.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    if resp.StatusCode >= 400 {
        return fmt.Errorf("webhook returned status %d", resp.StatusCode)
    }

    return nil
}

reporter.Init(reporter.Config{
    AppName:          "payment-service",
    AppEnv:           "production",
    EnablePublishing: true,
    Publisher: &WebhookPublisher{
        endpoint: "https://alerts.example.com/reporter",
        client:   http.DefaultClient,
    },
})

if err := validateState(order); err != nil {
    return reporter.WrapWithSeverity(
        err,
        reporter.SeverityDanger,
        "Checkout state is inconsistent after payment confirmation",
    )
}

type Config struct {
    AppName          string
    AppEnv           string
    KafkaBrokers     []string
    KafkaTopic       string
    EnablePublishing bool
    Publisher        Publisher
    PublishMinSeverity string
    AutoWrapFallbackSeverity string
}

type Publisher interface {
    Publish(ctx context.Context, report *CustomError) error
}

type ClosePublisher interface {
    Close() error
}

type ReportOptions struct {
    Description string
    Severity    string
    ErrorType   string
    StatusCode  int
}

func NewKafkaPublisher(brokers []string, topic string) *KafkaPublisher
func NewRedisPublisher(client *redis.Client, listName string) *RedisPublisher
func NewRedisListPublisher(client *redis.Client, listName string) *RedisPublisher
func Init(cfg Config)
func SetPublisher(p Publisher)
func Close()
func Flush()
func AutoWrap(err error) error
func Wrap(err error, customDesc string) error
func WrapWithSeverity(err error, severity, customDesc string) error
func WrapHTTPStatus(err error, statusCode int, customDesc string) error
func WrapReport(err error, opts ReportOptions) error

err := reporter.AutoWrap(rawErr)
if customErr, ok := err.(*reporter.CustomError); ok {
    _ = customErr.ErrorType
    _ = customErr.File
    _ = customErr.Line
}