feat: migrate to zap for logging

Resolves #19, #7

Author: benjivesterby

.gitignore

@@ -1,4 +1,5 @@
 void
+config.yaml
 
 dist/
 

.pre-commit-config.yaml

@@ -8,26 +8,26 @@ repos:
   #        entry: detect-secrets-hook
   #        args: ['--baseline', '.secrets.baseline']
 -   repo: https://github.com/golangci/golangci-lint
-    rev: v1.49.0
+    rev: v1.52.2
     hooks:
     -   id: golangci-lint
 -   repo: https://github.com/Bahjat/pre-commit-golang    
     rev: v1.0.3 # pragma: allowlist secret
     hooks:
       - id: go-unit-tests
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.3.0
+    rev: v4.4.0
     hooks:
     -   id: check-json
     -   id: check-added-large-files
     -   id: pretty-format-json
     -   id: check-merge-conflict
     -   id: check-yaml
 -   repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.32.2
+    rev: v0.34.0
     hooks:
     -   id: markdownlint-fix
 -   repo: https://github.com/koalaman/shellcheck-precommit
-    rev: v0.8.0
+    rev: v0.9.0
     hooks:
     -   id: shellcheck

allow.go

@@ -4,37 +4,36 @@ import (
 	"context"
 
 	"github.com/miekg/dns"
-	"go.devnw.com/event"
 )
 
 func AllowResolver(
 	ctx context.Context,
-	pub *event.Publisher,
+	logger Logger,
 	upstream chan<- *Request,
 	records ...*Record,
 ) (*Allow, error) {
-	err := checkNil(ctx, pub)
+	err := checkNil(ctx, logger)
 	if err != nil {
 		return nil, err
 	}
 
-	m, err := NewMatcher(ctx, pub, records...)
+	m, err := NewMatcher(ctx, logger, records...)
 	if err != nil {
 		return nil, err
 	}
 
 	return &Allow{
 		Matcher:  m,
 		ctx:      ctx,
-		pub:      pub,
+		logger:   logger,
 		upstream: upstream,
 	}, nil
 }
 
 type Allow struct {
 	*Matcher
 	ctx      context.Context
-	pub      *event.Publisher
+	logger   Logger
 	upstream chan<- *Request
 }
 
@@ -54,15 +53,13 @@ func (a *Allow) Intercept(
 	case <-a.ctx.Done():
 	case <-ctx.Done():
 	case a.upstream <- req:
-		a.pub.EventFunc(ctx, func() event.Event {
-			return &Event{
-				Msg:      "query found in allow list",
-				Name:     req.r.Question[0].Name,
-				Type:     dns.Type(req.r.Question[0].Qtype),
-				Category: ALLOW,
-				Record:   record,
-			}
-		})
+		a.logger.Debugw(
+			"matched",
+			"category", ALLOW,
+			"name", req.r.Question[0].Name,
+			"type", dns.Type(req.r.Question[0].Qtype),
+			"record", record,
+		)
 	}
 
 	return nil, false

block.go

@@ -4,35 +4,34 @@ import (
 	"context"
 
 	"github.com/miekg/dns"
-	"go.devnw.com/event"
 )
 
 func BlockResolver(
 	ctx context.Context,
-	pub *event.Publisher,
+	logger Logger,
 	records ...*Record,
 ) (*Block, error) {
-	err := checkNil(ctx, pub)
+	err := checkNil(ctx, logger)
 	if err != nil {
 		return nil, err
 	}
 
-	m, err := NewMatcher(ctx, pub, records...)
+	m, err := NewMatcher(ctx, logger, records...)
 	if err != nil {
 		return nil, err
 	}
 
 	return &Block{
 		Matcher: m,
 		ctx:     ctx,
-		pub:     pub,
+		logger:  logger,
 	}, nil
 }
 
 type Block struct {
 	*Matcher
-	ctx context.Context
-	pub *event.Publisher
+	ctx    context.Context
+	logger Logger
 }
 
 func (b *Block) Intercept(
@@ -49,22 +48,26 @@ func (b *Block) Intercept(
 	// Matched a blocked record
 	err := req.Block()
 	if err != nil {
-		b.pub.ErrorFunc(ctx, func() error {
-			return NewErr(req, err, "failed to block request")
-		})
+		b.logger.Errorw(
+			"failed to block",
+			"category", BLOCK,
+			"name", req.r.Question[0].Name,
+			"type", dns.Type(req.r.Question[0].Qtype),
+			"record", record,
+			"client", req.client,
+			"server", req.server,
+		)
 	}
 
-	b.pub.EventFunc(ctx, func() event.Event {
-		return &Event{
-			Msg:      "query found in block list",
-			Name:     req.r.Question[0].Name,
-			Type:     dns.Type(req.r.Question[0].Qtype),
-			Category: BLOCK,
-			Record:   record,
-			Server:   req.server,
-			Client:   req.client,
-		}
-	})
+	b.logger.Infow(
+		"matched",
+		"category", BLOCK,
+		"name", req.r.Question[0].Name,
+		"type", dns.Type(req.r.Question[0].Qtype),
+		"record", record,
+		"client", req.client,
+		"server", req.server,
+	)
 
 	return nil, false
 }

cache.go

@@ -9,14 +9,13 @@ import (
 	"time"
 
 	"github.com/miekg/dns"
-	"go.devnw.com/event"
 	"go.devnw.com/ttl"
 )
 
 type Cache struct {
-	ctx   context.Context
-	pub   *event.Publisher
-	cache *ttl.Cache[string, *dns.Msg]
+	ctx    context.Context
+	logger Logger
+	cache  *ttl.Cache[string, *dns.Msg]
 }
 
 // Intercept is the cache intercept func which attempts to first pull
@@ -31,43 +30,37 @@ func (c *Cache) Intercept(
 	if len(req.r.Question) == 0 {
 		err := req.Block()
 		if err != nil {
-			c.pub.ErrorFunc(ctx, func() error {
-				return Error{
-					Category: CACHE,
-					Server:   "cache",
-					Msg:      "failed to answer request",
-					Inner:    err,
-					Record:   req.String(),
-				}
-			})
+			c.logger.Errorw(
+				"invalid question",
+				"category", CACHE,
+				"request", req.String(),
+				"error", err,
+			)
 		}
 	}
 
 	r, ok := c.cache.Get(c.ctx, req.Key())
 	if !ok || r == nil {
 		// Add hook for final response to cache
 		req.w = &interceptor{
-			ctx:   c.ctx,
-			cache: c.cache,
-			pub:   c.pub,
-			req:   req,
-			next:  req.w.WriteMsg, // TODO: Determine if this is the correct pattern
+			ctx:    c.ctx,
+			cache:  c.cache,
+			logger: c.logger,
+			req:    req,
+			next:   req.w.WriteMsg, // TODO: Determine if this is the correct pattern
 		}
 
 		return req, true
 	}
 
 	err := req.Answer(r.SetReply(req.r))
 	if err != nil {
-		c.pub.ErrorFunc(ctx, func() error {
-			return Error{
-				Category: CACHE,
-				Server:   "cache",
-				Msg:      "failed to answer request",
-				Inner:    err,
-				Record:   req.String(),
-			}
-		})
+		c.logger.Errorw(
+			"failed to set reply",
+			"category", CACHE,
+			"request", req.String(),
+			"error", err,
+		)
 	}
 
 	return req, false
@@ -77,12 +70,12 @@ func (c *Cache) Intercept(
 // for future queries so that they are not re-requesting an updated
 // IP for an address that has already been queried.
 type interceptor struct {
-	ctx   context.Context
-	cache *ttl.Cache[string, *dns.Msg]
-	pub   *event.Publisher
-	req   *Request
-	next  func(*dns.Msg) error
-	once  sync.Once
+	ctx    context.Context
+	cache  *ttl.Cache[string, *dns.Msg]
+	logger Logger
+	req    *Request
+	next   func(*dns.Msg) error
+	once   sync.Once
 }
 
 func (i *interceptor) WriteMsg(res *dns.Msg) (err error) {
@@ -99,13 +92,12 @@ func (i *interceptor) WriteMsg(res *dns.Msg) (err error) {
 			return
 		}
 
-		i.pub.EventFunc(i.ctx, func() event.Event {
-			return &CacheEvent{
-				Method: WRITE,
-				Record: i.req.r.Question[0].Name,
-				TTL:    ttl,
-			}
-		})
+		i.logger.Debugw(
+			"cache",
+			"method", WRITE,
+			"record", i.req.r.Question[0].Name,
+			"ttl", ttl,
+		)
 	})
 
 	if err != nil {

config.go

@@ -1,19 +1,5 @@
 package main
 
-import (
-	gen "go.structs.dev/gen"
-)
-
-// Config defines the configuration options available for void.
-type Config struct {
-	Port     int                     `json:"listen_port"`
-	TTL      int                     `json:"ttl"`
-	Local    gen.Map[string, Record] `json:"local_records"`
-	Allow    gen.Map[string, Record] `json:"allow_records"`
-	Deny     gen.Map[string, Record] `json:"deny_records"`
-	CacheDir string                  `json:"cache_dir"`
-}
-
 // Type indicates the type of a record to ensure proper analysis.
 type Type string
 

deployment/config/config.yaml

@@ -70,17 +70,20 @@
 # Logger configures the log location and log rotation settings.
 #
 # Uses configuration from https://github.com/natefinch/lumberjack/tree/v2.0
-logger:
-  filename: "/var/log/void/void.log"
-  maxage: 30
-  # maxsize: 100 # MB
-  # maxbackups: 10
-  # localtime: false
-  compress: true
+logger: 
+    # Path to log file or :stdout: for stdout
+    # Leave empty to log to stderr
+    filename: "/var/log/void/void.log"
+    level: "error" # debug, info, warn, error, fatal
+    format: "json" # or "console"
+    maxage: 30
+    maxsize: 100 # MB
+    maxbackups: 10
+    localtime: true
+    compress: true
 
 verbose: false
 
-
 dns:
   #port: 53 # default
   #upstream: [ # default