nanolog: github.com/ScottMansfield/nanolog Index | Files | Directories

package nanolog

import "github.com/ScottMansfield/nanolog"

Package nanolog is a package to speed up your logging.

The format string is inspired by the full fledged fmt.Fprintf function. The codes are unique to this package, so normal fmt documentation is not be applicable.

The format string is similar to fmt in that it uses the percent sign (a.k.a. the modulo operator) to signify the start of a format code. The reader is greedy, meaning that the parser will attempt to read as much as it can for a code before it stops. E.g. if you have a generic int in the middle of your format string immediately followed by the number 1 and a space ("%i1 "), the parser may complain saying that it encountered an invalid code. To fix this, use curly braces after the percent sign to surround the code: "%{i}1 ".

Kinds and their corresponding format codes:

Kind          | Code
--------------|-------------
Bool          | b
Int           | i
Int8          | i8
Int16         | i16
Int32         | i32
Int64         | i64
Uint          | u
Uint8         | u8
Uint16        | u16
Uint32        | u32
Uint64        | u64
Uintptr       |
Float32       | f32
Float64       | f64
Complex64     | c64
Complex128    | c128
Array         |
Chan          |
Func          |
Interface     |
Map           |
Ptr           |
Slice         |
String        | s
Struct        |
UnsafePointer |

The file format has two categories of data:

1. Log line information to reconstruct logs later
2. Actual log entries

The differentiation is done with the entryType, which is prefixed on to the record.

The log line records are formatted as follows:

- type:             1 byte - ETLogLine (1)
- id:               4 bytes - little endian uint32
- # of string segs: 4 bytes - little endian uint32
- kinds:            (#segs - 1) bytes, each being a reflect.Kind
- segments:
  - string length:  4 bytes - little endian uint32
  - string data:    ^length bytes

The log entry records are formatted as follows:

- type:    1 byte - ETLogEntry (2)
- line id: 4 bytes - little endian uint32
- data+:   var bytes - all the corresponding data for the kinds in the log line entry

The data is serialized as follows:

- Bool: 1 byte
  - False: 0 or True: 1

- String: 4 + len(string) bytes
  - Length: 4 bytes - little endian uint32
  - String bytes: Length bytes

- int family:
   - int:    8 bytes - int64 as little endian uint64
   - int8:  1 byte
   - int16: 2 bytes - int16 as little endian uint16
   - int32: 4 bytes - int32 as little endian uint32
   - int64: 8 bytes - int64 as little endian uint64

- uint family:
  - uint:   8 bytes - little endian uint64
  - uint8:  1 byte
  - uint16: 2 bytes - little endian uint16
  - uint32: 4 bytes - little endian uint32
  - uint64: 8 bytes - little endian uint64

- float32:
  - 4 bytes as little endian uint32 from float32 bits

- float64:
  - 8 bytes as little endian uint64 from float64 bits

- complex64:
  - Real:    4 bytes as little endian uint32 from float32 bits
  - Complex: 4 bytes as little endian uint32 from float32 bits

- complex128:
  - Real:    8 bytes as little endian uint64 from float64 bits
  - Complex: 8 bytes as little endian uint64 from float64 bits

Index

Package Files

nanolog.go

Constants

const MaxLoggers = 10240

MaxLoggers is the maximum number of different loggers that are allowed

func Flush Uses

func Flush() error

Flush calls LogWriter.Flush on the default log writer.

func Log Uses

func Log(handle Handle, args ...interface{}) error

Log calls LogWriter.Log on the default log writer.

func SetWriter Uses

func SetWriter(new io.Writer) error

SetWriter calls LogWriter.SetWriter on the default log writer.

type EntryType Uses

type EntryType byte

EntryType is an enum that represents the record headers in the output files to differentiate between log lines and log entries

const (
    // ETInvalid is an invalid EntryType
    ETInvalid EntryType = iota

    // ETLogLine means the log line data for a single call to AddLogger is ahead
    ETLogLine

    // ETLogEntry means the log data for a single call to Log is ahead
    ETLogEntry
)

type Handle Uses

type Handle uint32

Handle is a simple handle to an internal logging data structure LogHandles are returned by the AddLogger method and used by the Log method to actually log data.

func AddLogger Uses

func AddLogger(fmt string) Handle

AddLogger calls LogWriter.AddLogger on the default log writer.

type LogWriter Uses

type LogWriter interface {
    // SetWriter will set up efficient writing for the log to the output stream given.
    // A raw IO stream is best. The first time SetWriter is called any logs that were
    // created or posted before the call will be sent to the writer all in one go.
    SetWriter(new io.Writer) error
    // Flush ensures all log entries written up to this point are written to the underlying io.Writer
    Flush() error
    // AddLogger initializes a logger and returns a handle for future logging
    AddLogger(fmt string) Handle
    // Log logs to the output stream
    Log(handle Handle, args ...interface{}) error
}

func New Uses

func New() LogWriter

New creates a new LogWriter

type Logger Uses

type Logger struct {
    Kinds []reflect.Kind
    Segs  []string
}

Logger is the internal struct representing the runtime state of the loggers. The Segs field is not used during logging; it is only used in the inflate utility

Directories

PathSynopsis
reader
test
test/pkg

Package nanolog imports 10 packages (graph) and is imported by 3 packages. Updated 2017-05-01. Refresh now. Tools for package owners.