log

package

v0.0.0-...-6a0185f Latest Latest Go to latest Published: Oct 7, 2017 License: Apache-2.0 Imports: 15 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/isolus/coredns

Links

Open Source Insights

README ¶

log

log enables query logging to standard output.

Syntax

log

With no arguments, a query log entry is written to stdout in the common log format for all requests

log FILE

FILE is the log file to create (or append to). The only valid name for FILE is stdout.

log [NAME] FILE [FORMAT]

NAME is the name to match in order to be logged
FILE is the log file (again only stdout is allowed here).
FORMAT is the log format to use (default is Common Log Format)

You can further specify the class of responses that get logged:

log [NAME] FILE [FORMAT] {
    class [success|denial|error|all]
}

Here success denial and error denotes the class of responses that should be logged. The classes have the following meaning:

success: successful response
denial: either NXDOMAIN or NODATA (name exists, type does not)
error: SERVFAIL, NOTIMP, REFUSED, etc. Anything that indicates the remote server is not willing to resolve the request.
all: the default - nothing is specified.

If no class is specified, it defaults to all.

Log File

The "log file" can only be stdout. CoreDNS expects another service to pick up this output and deal with it, i.e. journald when using systemd or Docker's logging capabilities.

Log Format

You can specify a custom log format with any placeholder values. Log supports both request and response placeholders.

The following place holders are supported:

{type}: qtype of the request
{name}: qname of the request
{class}: qclass of the request
{proto}: protocol used (tcp or udp)
{when}: time of the query
{remote}: client's IP address
{size}: request size in bytes
{port}: client's port
{duration}: response duration
{rcode}: response RCODE
{rsize}: response size
{>rflags}: response flags, each set flag will be displayed, e.g. "aa, tc". This includes the qr bit as well.
{>bufsize}: the EDNS0 buffer size advertised in the query
{>do}: is the EDNS0 DO (DNSSEC OK) bit set in the query
{>id}: query ID
{>opcode}: query OPCODE

The default Common Log Format is:

`{remote} - [{when}] "{type} {class} {name} {proto} {size} {>do} {>bufsize}" {rcode} {>rflags} {rsize} {duration}`

Examples

Log all requests to stdout

log stdout

Custom log format, for all zones (.)

log . stdout "{proto} Request: {name} {type} {>id}"

Only log denials for example.org (and below to a file)

log example.org stdout {
    class denial
}

Documentation ¶

Overview ¶

Package log implements basic but useful request (access) logging plugin.

Index ¶

Constants
type Logger
- func (l Logger) Name() string
- func (l Logger) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) (int, error)
type Rule

Constants ¶

View Source

const (
	// DefaultLogFilename is the default output name. This is the only supported value.
	DefaultLogFilename = "stdout"
	// CommonLogFormat is the common log format.
	CommonLogFormat = `{remote} ` + CommonLogEmptyValue + ` [{when}] "{type} {class} {name} {proto} {size} {>do} {>bufsize}" {rcode} {>rflags} {rsize} {duration}`
	// CommonLogEmptyValue is the common empty log value.
	CommonLogEmptyValue = "-"
	// CombinedLogFormat is the combined log format.
	CombinedLogFormat = CommonLogFormat + ` "{>opcode}"`
	// DefaultLogFormat is the default log format.
	DefaultLogFormat = CommonLogFormat
)

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type Logger ¶

type Logger struct {
	Next      plugin.Handler
	Rules     []Rule
	ErrorFunc func(dns.ResponseWriter, *dns.Msg, int) // failover error handler
}

Logger is a basic request logging plugin.

func (Logger) Name ¶

func (l Logger) Name() string

Name implements the Handler interface.

func (Logger) ServeDNS ¶

func (l Logger) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) (int, error)

ServeDNS implements the plugin.Handler interface.

type Rule ¶

type Rule struct {
	NameScope  string
	Class      response.Class
	OutputFile string
	Format     string
	Log        *log.Logger
}

Rule configures the logging plugin.

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL