Raise copyright years

[nncp.git] / src / log.go

diff --git a/src/log.go b/src/log.go
index 78f9acc8e99083740f9fbfdf0ccc234f474b07e5..7953a0227afe14836cb878ccbe10fa4020ad8539 100644 (file)
--- a/src/log.go
+++ b/src/log.go
@@ -1,6 +1,6 @@
 /*
 NNCP -- Node to Node copy, utilities for store-and-forward data exchange
-Copyright (C) 2016-2021 Sergey Matveev <stargrave@stargrave.org>
+Copyright (C) 2016-2022 Sergey Matveev <stargrave@stargrave.org>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -21,6 +21,7 @@ import (
        "bytes"
        "fmt"
        "os"
+       "sync"
        "time"
 
        "go.cypherpunks.ru/recfile"
@@ -29,7 +30,10 @@ import (
 
 const LogFdPrefix = "FD:"
 
-var LogFd *os.File
+var (
+       LogFd     *os.File
+       LogFdLock sync.Mutex
+)
 
 type LE struct {
        K string
@@ -38,38 +42,53 @@ type LE struct {
 type LEs []LE
 
 func (les LEs) Rec() string {
-       fields := make([]recfile.Field, 0, len(les)+1)
-       fields = append(fields, recfile.Field{
-               Name: "When", Value: time.Now().UTC().Format(time.RFC3339Nano),
-       })
-       var val string
-       for _, le := range les {
-               switch v := le.V.(type) {
-               case int, int8, uint8, int64, uint64:
-                       val = fmt.Sprintf("%d", v)
-               case bool:
-                       val = fmt.Sprintf("%v", v)
-               default:
-                       val = fmt.Sprintf("%s", v)
-               }
-               fields = append(fields, recfile.Field{Name: le.K, Value: val})
-       }
        b := bytes.NewBuffer(make([]byte, 0, 1<<10))
        w := recfile.NewWriter(b)
        _, err := w.RecordStart()
        if err != nil {
                panic(err)
        }
-       _, err = w.WriteFields(fields...)
+       _, err = w.WriteFields(recfile.Field{
+               Name:  "When",
+               Value: time.Now().UTC().Format(time.RFC3339Nano),
+       })
        if err != nil {
                panic(err)
        }
+       for _, le := range les {
+               switch v := le.V.(type) {
+               case int, int8, uint8, int64, uint64:
+                       _, err = w.WriteFields(recfile.Field{
+                               Name:  le.K,
+                               Value: fmt.Sprintf("%d", v),
+                       })
+               case bool:
+                       _, err = w.WriteFields(recfile.Field{
+                               Name:  le.K,
+                               Value: fmt.Sprintf("%v", v),
+                       })
+               case []string:
+                       if len(v) > 0 {
+                               _, err = w.WriteFieldMultiline(le.K, v)
+                       }
+               default:
+                       _, err = w.WriteFields(recfile.Field{
+                               Name:  le.K,
+                               Value: fmt.Sprintf("%s", v),
+                       })
+               }
+               if err != nil {
+                       panic(err)
+               }
+       }
        return b.String()
 }
 
 func (ctx *Ctx) Log(rec string) {
        if LogFd != nil {
+               LogFdLock.Lock()
                LogFd.WriteString(rec)
+               LogFdLock.Unlock()
                return
        }
        fdLock, err := os.OpenFile(
@@ -115,6 +134,9 @@ func (ctx *Ctx) LogI(who string, les LEs, msg func(LEs) string) {
        les = append(LEs{{"Who", who}}, les...)
        les = append(les, LE{"Msg", msg(les)})
        rec := les.Rec()
+       if ctx.Debug {
+               fmt.Fprint(os.Stderr, rec)
+       }
        if !ctx.Quiet {
                fmt.Fprintln(os.Stderr, ctx.HumanizeRec(rec))
        }
@@ -125,6 +147,9 @@ func (ctx *Ctx) LogE(who string, les LEs, err error, msg func(LEs) string) {
        les = append(LEs{{"Err", err.Error()}, {"Who", who}}, les...)
        les = append(les, LE{"Msg", msg(les)})
        rec := les.Rec()
+       if ctx.Debug {
+               fmt.Fprint(os.Stderr, rec)
+       }
        if !ctx.Quiet {
                fmt.Fprintln(os.Stderr, ctx.HumanizeRec(rec))
        }