package main

import (
    "os"

    "github.com/dekarrin/jellog"
)

func main() {
    jellog.Printf("The program has started")

    f, err := os.Open("somefile.txt")
    if err != nil {
        jellog.Fatalf("Can't open somefile.txt: %v", err)
    }
    defer f.Close()

    jellog.Printf("The program is done!")
}

package main

import (
    "fmt"
    "io"
    "os"
    "http"

    "github.com/dekarrin/jellog"
)

var log jellog.Logger[string]

func main() {
    log = jellog.New(jellog.Defaults[string]().
        WithComponent("server").
        WithHandler(
            // only show INFO-level or higher in stderr
            jellog.LvInfo, jellog.NewStderrHandler(nil),
        ).
        WithHandler(
            // show all levels in the file output
            jellog.LvAll, jellog.MustOpenFile("server.log", nil),
        ))
    
    // and then start using it!
    log.Info("Initialize server...")

    log.Debug("Starting config load...")
    conf, err := loadConfig("server.yml")
    if err != nil {
        if !conf.defaultConf {
            log.Fatalf("Problem loading config: %w", err)
        }
    }
    log.Debug("Config load complete")

    server := createHTTPServer(conf)
    log.Debug("Server created")

    log.Infof("Server is now listening for new connections")
    log.Fatalf("%v", server.ListenAndServe())
}

func loadConfig(filename string) (Config, error) {
    log.Tracef("Open file...")
    f, err := os.Open(filename)
    if err != nil {
        log.Warnf("config unreadable; using default config: can't open: %v", err)
        return Config{defaultConf: true}, err
    }
    defer f.Close()

    log.Tracef("About to start reading config...")
    confData, err := io.ReadAll(f)
    if err != nil {
        log.Errorf("%v", err)
        return Config{}, err
    }
    log.Tracef("Finished reading config")

    log.Tracef("About to start parsing config...")
    conf, err := parseConfig(confData)
    if err != nil {
        log.Errorf("%v", err)
        return Config{}, err
    }
    log.Tracef("Finished parsing config")
    return conf, nil
}

func parseConfig(data []byte) (Config, error) {
    // ...
    //
    // do some stuff with config, eventually end up with a:

    return Config{Port: 20, Address: "localhost"}, nil
}

func createHTTPServer(conf Config) *http.Server {
    return &http.Server{
        Addr: fmt.Sprintf("%s:%d", conf.Address, conf.Port),
    }
}

type Config struct {
    defaultConf bool
    Port int
    Address string
}