aboutsummaryrefslogtreecommitdiff
path: root/middleware/log
diff options
context:
space:
mode:
Diffstat (limited to 'middleware/log')
-rw-r--r--middleware/log/setup.go141
-rw-r--r--middleware/log/setup_test.go137
2 files changed, 278 insertions, 0 deletions
diff --git a/middleware/log/setup.go b/middleware/log/setup.go
new file mode 100644
index 000000000..a80e69ac3
--- /dev/null
+++ b/middleware/log/setup.go
@@ -0,0 +1,141 @@
+package log
+
+import (
+ "io"
+ "log"
+ "os"
+
+ "github.com/miekg/coredns/core/dnsserver"
+ "github.com/miekg/coredns/middleware"
+ "github.com/miekg/coredns/server"
+
+ "github.com/hashicorp/go-syslog"
+ "github.com/mholt/caddy"
+ "github.com/miekg/dns"
+)
+
+func init() {
+ caddy.RegisterPlugin("log", caddy.Plugin{
+ ServerType: "dns",
+ Action: setup,
+ })
+}
+
+func setup(c *caddy.Controller) error {
+ rules, err := logParse(c)
+ if err != nil {
+ return err
+ }
+
+ // Open the log files for writing when the server starts
+ c.OnStartup(func() error {
+ for i := 0; i < len(rules); i++ {
+ var err error
+ var writer io.Writer
+
+ if rules[i].OutputFile == "stdout" {
+ writer = os.Stdout
+ } else if rules[i].OutputFile == "stderr" {
+ writer = os.Stderr
+ } else if rules[i].OutputFile == "syslog" {
+ writer, err = gsyslog.NewLogger(gsyslog.LOG_INFO, "LOCAL0", "coredns")
+ if err != nil {
+ return err
+ }
+ } else {
+ var file *os.File
+ file, err = os.OpenFile(rules[i].OutputFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
+ if err != nil {
+ return err
+ }
+ if rules[i].Roller != nil {
+ file.Close()
+ rules[i].Roller.Filename = rules[i].OutputFile
+ writer = rules[i].Roller.GetLogWriter()
+ } else {
+ writer = file
+ }
+ }
+
+ rules[i].Log = log.New(writer, "", 0)
+ }
+
+ return nil
+ })
+
+ dnsserver.GetConfig(c).AddMiddleware(func(next dnsserver.Handler) dnsserver.Handler {
+ return Logger{Next: next, Rules: rules, ErrorFunc: server.DefaultErrorFunc}
+ })
+
+ return nil
+}
+
+func logParse(c *caddy.Controller) ([]Rule, error) {
+ var rules []Rule
+
+ for c.Next() {
+ args := c.RemainingArgs()
+
+ var logRoller *middleware.LogRoller
+ if c.NextBlock() {
+ if c.Val() == "rotate" {
+ if c.NextArg() {
+ if c.Val() == "{" {
+ var err error
+ logRoller, err = middleware.ParseRoller(c)
+ if err != nil {
+ return nil, err
+ }
+ // This part doesn't allow having something after the rotate block
+ if c.Next() {
+ if c.Val() != "}" {
+ return nil, c.ArgErr()
+ }
+ }
+ }
+ }
+ }
+ }
+ if len(args) == 0 {
+ // Nothing specified; use defaults
+ rules = append(rules, Rule{
+ NameScope: ".",
+ OutputFile: DefaultLogFilename,
+ Format: DefaultLogFormat,
+ Roller: logRoller,
+ })
+ } else if len(args) == 1 {
+ // Only an output file specified
+ rules = append(rules, Rule{
+ NameScope: ".",
+ OutputFile: args[0],
+ Format: DefaultLogFormat,
+ Roller: logRoller,
+ })
+ } else {
+ // Name scope, output file, and maybe a format specified
+
+ format := DefaultLogFormat
+
+ if len(args) > 2 {
+ switch args[2] {
+ case "{common}":
+ format = CommonLogFormat
+ case "{combined}":
+ format = CombinedLogFormat
+ default:
+ format = args[2]
+ }
+ }
+
+ rules = append(rules, Rule{
+ NameScope: dns.Fqdn(args[0]),
+ OutputFile: args[1],
+ Format: format,
+ Roller: logRoller,
+ })
+ }
+ }
+
+ return rules, nil
+}
diff --git a/middleware/log/setup_test.go b/middleware/log/setup_test.go
new file mode 100644
index 000000000..0a3ee63fe
--- /dev/null
+++ b/middleware/log/setup_test.go
@@ -0,0 +1,137 @@
+package log
+
+import (
+ "testing"
+
+ "github.com/miekg/coredns/middleware"
+
+ "github.com/mholt/caddy"
+)
+
+func TestLogParse(t *testing.T) {
+ tests := []struct {
+ inputLogRules string
+ shouldErr bool
+ expectedLogRules []Rule
+ }{
+ {`log`, false, []Rule{{
+ NameScope: ".",
+ OutputFile: DefaultLogFilename,
+ Format: DefaultLogFormat,
+ }}},
+ {`log log.txt`, false, []Rule{{
+ NameScope: ".",
+ OutputFile: "log.txt",
+ Format: DefaultLogFormat,
+ }}},
+ {`log example.org log.txt`, false, []Rule{{
+ NameScope: "example.org.",
+ OutputFile: "log.txt",
+ Format: DefaultLogFormat,
+ }}},
+ {`log example.org. stdout`, false, []Rule{{
+ NameScope: "example.org.",
+ OutputFile: "stdout",
+ Format: DefaultLogFormat,
+ }}},
+ {`log example.org log.txt {common}`, false, []Rule{{
+ NameScope: "example.org.",
+ OutputFile: "log.txt",
+ Format: CommonLogFormat,
+ }}},
+ {`log example.org accesslog.txt {combined}`, false, []Rule{{
+ NameScope: "example.org.",
+ OutputFile: "accesslog.txt",
+ Format: CombinedLogFormat,
+ }}},
+ {`log example.org. log.txt
+ log example.net accesslog.txt {combined}`, false, []Rule{{
+ NameScope: "example.org.",
+ OutputFile: "log.txt",
+ Format: DefaultLogFormat,
+ }, {
+ NameScope: "example.net.",
+ OutputFile: "accesslog.txt",
+ Format: CombinedLogFormat,
+ }}},
+ {`log example.org stdout {host}
+ log example.org log.txt {when}`, false, []Rule{{
+ NameScope: "example.org.",
+ OutputFile: "stdout",
+ Format: "{host}",
+ }, {
+ NameScope: "example.org.",
+ OutputFile: "log.txt",
+ Format: "{when}",
+ }}},
+ {`log access.log { rotate { size 2 age 10 keep 3 } }`, false, []Rule{{
+ NameScope: ".",
+ OutputFile: "access.log",
+ Format: DefaultLogFormat,
+ Roller: &middleware.LogRoller{
+ MaxSize: 2,
+ MaxAge: 10,
+ MaxBackups: 3,
+ LocalTime: true,
+ },
+ }}},
+ }
+ for i, test := range tests {
+ c := caddy.NewTestController("dns", test.inputLogRules)
+ actualLogRules, err := logParse(c)
+
+ if err == nil && test.shouldErr {
+ t.Errorf("Test %d didn't error, but it should have", i)
+ } else if err != nil && !test.shouldErr {
+ t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
+ }
+ if len(actualLogRules) != len(test.expectedLogRules) {
+ t.Fatalf("Test %d expected %d no of Log rules, but got %d ",
+ i, len(test.expectedLogRules), len(actualLogRules))
+ }
+ for j, actualLogRule := range actualLogRules {
+
+ if actualLogRule.NameScope != test.expectedLogRules[j].NameScope {
+ t.Errorf("Test %d expected %dth LogRule NameScope to be %s , but got %s",
+ i, j, test.expectedLogRules[j].NameScope, actualLogRule.NameScope)
+ }
+
+ if actualLogRule.OutputFile != test.expectedLogRules[j].OutputFile {
+ t.Errorf("Test %d expected %dth LogRule OutputFile to be %s , but got %s",
+ i, j, test.expectedLogRules[j].OutputFile, actualLogRule.OutputFile)
+ }
+
+ if actualLogRule.Format != test.expectedLogRules[j].Format {
+ t.Errorf("Test %d expected %dth LogRule Format to be %s , but got %s",
+ i, j, test.expectedLogRules[j].Format, actualLogRule.Format)
+ }
+ if actualLogRule.Roller != nil && test.expectedLogRules[j].Roller == nil || actualLogRule.Roller == nil && test.expectedLogRules[j].Roller != nil {
+ t.Fatalf("Test %d expected %dth LogRule Roller to be %v, but got %v",
+ i, j, test.expectedLogRules[j].Roller, actualLogRule.Roller)
+ }
+ if actualLogRule.Roller != nil && test.expectedLogRules[j].Roller != nil {
+ if actualLogRule.Roller.Filename != test.expectedLogRules[j].Roller.Filename {
+ t.Fatalf("Test %d expected %dth LogRule Roller Filename to be %s, but got %s",
+ i, j, test.expectedLogRules[j].Roller.Filename, actualLogRule.Roller.Filename)
+ }
+ if actualLogRule.Roller.MaxAge != test.expectedLogRules[j].Roller.MaxAge {
+ t.Fatalf("Test %d expected %dth LogRule Roller MaxAge to be %d, but got %d",
+ i, j, test.expectedLogRules[j].Roller.MaxAge, actualLogRule.Roller.MaxAge)
+ }
+ if actualLogRule.Roller.MaxBackups != test.expectedLogRules[j].Roller.MaxBackups {
+ t.Fatalf("Test %d expected %dth LogRule Roller MaxBackups to be %d, but got %d",
+ i, j, test.expectedLogRules[j].Roller.MaxBackups, actualLogRule.Roller.MaxBackups)
+ }
+ if actualLogRule.Roller.MaxSize != test.expectedLogRules[j].Roller.MaxSize {
+ t.Fatalf("Test %d expected %dth LogRule Roller MaxSize to be %d, but got %d",
+ i, j, test.expectedLogRules[j].Roller.MaxSize, actualLogRule.Roller.MaxSize)
+ }
+ if actualLogRule.Roller.LocalTime != test.expectedLogRules[j].Roller.LocalTime {
+ t.Fatalf("Test %d expected %dth LogRule Roller LocalTime to be %t, but got %t",
+ i, j, test.expectedLogRules[j].Roller.LocalTime, actualLogRule.Roller.LocalTime)
+ }
+ }
+ }
+ }
+
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-01 11:15:15 +0000