Logging#

The boxes and glue backend creates an instance of a zap SugaredLogger. This logger implements a printf-style API, for example

bag.Logger.Infof("Read font file %s", myfontfile)

The default output is JSON, but you can easily change this to your needs. See the documentation of the zap logger. Here are two examples on how to change the log output.

Getting an unstructured line based logging#

func newZapLogger() error {
    cfg := zap.Config{
        Encoding:    "console",
        OutputPaths: []string{"stdout"},
        Level: zap.NewAtomicLevelAt(zapcore.DebugLevel),
        EncoderConfig: zapcore.EncoderConfig{
            EncodeLevel: zapcore.LowercaseColorLevelEncoder,
            LevelKey:    "level",
            MessageKey:  "message",
        },
    }

    logger, err := cfg.Build()
    if err != nil {
        return err
    }
    bag.Logger = logger.Sugar()
    return nil
}

if err := newZapLogger(); err != nil {
    return err
}

This creates a simple line base output, such as

info    XTS start version 0.0.2
info    Define font family "text"
info    Define text format "text"
info    Define text format "left"
info    Define text format "right"
info    Define text format "center"
info    Define new page type "default page"
info    Start processing data
info    Page 1 type default page created wd: 20, ht: 65 grid cells
info    Load font /Users/patrick/work/software/bag/xts/fonts/texgyreheros/texgyreheros-regular.otf
info    Page 2 type default page created wd: 20, ht: 65 grid cells
info    Load image /Users/patrick/work/software/bag/xts/playground/img/ocean.pdf
info    Write image /Users/patrick/work/software/bag/xts/playground/img/ocean.pdf to PDF
info    Write font /Users/patrick/work/software/bag/xts/fonts/texgyreheros/texgyreheros-regular.otf to PDF
info    Output written to publisher.pdf (79328 bytes)
info    Finished in 19.83625ms

Splitting the log file into a standard output and a protocol file#

This example defines two outputs, a colored logging to stdout and a perhaps verbose logging to a protocol file:

// Create a new logger instance which logs info to stdout and perhaps more to
// the protocol file.
func newZapLogger() (*zap.SugaredLogger, error) {
    protocolFile := "myfile.log"
    w, err := os.Create(protocolFile)
    if err != nil {
        return nil, err
    }

    infoPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
        return lvl >= zapcore.InfoLevel
    })
    debugPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
        return lvl >= zapcore.DebugLevel
    })

    var protocolPriority zap.LevelEnablerFunc
    if configuration.Verbose {
        protocolPriority = debugPriority
    } else {
        protocolPriority = infoPriority
    }

    colorEncoder := zapcore.EncoderConfig{
        EncodeLevel: zapcore.LowercaseColorLevelEncoder,
        LevelKey:    "level",
        MessageKey:  "message",
    }
    simpleEncoder := zapcore.EncoderConfig{
        EncodeLevel: zapcore.LowercaseLevelEncoder,
        LevelKey:    "level",
        MessageKey:  "message",
    }

    consoleDebugging := zapcore.Lock(os.Stdout)
    consoleEncoder := zapcore.NewConsoleEncoder(colorEncoder)

    fileEncoder := zapcore.NewConsoleEncoder(simpleEncoder)
    core := zapcore.NewTee(
        zapcore.NewCore(consoleEncoder, consoleDebugging, infoPriority),
        zapcore.NewCore(fileEncoder, w, protocolPriority),
    )

    logger := zap.New(core)
    return logger.Sugar(), nil
}

and initialize it with

if bag.Logger, err = newZapLogger(); err != nil {
    return err
}