RunOption change the behaviour of Run()

RROption is an option function configuring a Round Robin VirtualUpstream

Option is the type of configuration options for the statsd sink factory.

MOption is a function manipulating configuration state for a metrics Client.

RetryPolicy is a function deciding whether the request should be retried after a non-nil error from a call to the underlying RoundTripper

---

---

func initTOML() { Reset() SetConfigType("toml") r := bytes.NewReader(tomlExample) unmarshalReader(r, v.config) } make directories for testing fun

Note - The std lib alread had io.MultiWriter ---

Action is a function called when an OS signal is received.

--------------------- DefaultSubConfig -------------------------

AuditFunction is a function which will be called by a DynamicLogHandler after a HTTP request has been processed. It can be used for metrics by inspect

Cache is the interface needed to allow the RR upstream to remember where to send successful request for a period of time, (based on a cache key) to av

CleanupFunc is a function to call after a srv.Server is fully exited. A slice of CleanupFunc will be called after all servers are completely done. The

Client is the main object the applications holds to do metrics. It can be used directly for ad-hoc events, or be used to create persistent gauge/conte

First some interfaces to test on what can be done with Handlers CloneableHandler is a Handler which can clone itself for modification with the purpose

Command is the interface of a specific command

ConfigFunc is a function returning Servers and Cleanups for Run() to run. Run() will call this every time it needs to configure it self on start and o

ConfigLoader is a ConfigSource which needs explicit loading to refresh it's values

ConfigMarshalError happens when failing to marshal the configuration.

ConfigParseError denotes failing to parse configuration file.

ConfigSource is a case sensitive recursive store of config key/value (values can be maps)

ConfigureFunc is a function returning srv.Server to run and the CleanupFuncs to call when they have completely shut down. This function is deprecated.

Counter is different from a GaugeInt64 in that it is reset to zero every time its flushed - and thus being server-side maintained.

A DecoderConfigOption can be passed to hugorm.Unmarshal to configure mapstructure.DecoderConfig options

Descripter - A Server implementing the Descriptor interface will use that description in any logging

Dialer implements Dial* functions for connections which can be monitored by a IOActivityTimeout reaper

Duration allows you to have nice durations in your json config, like "10s"

temporary byte array for creating log lines. DynamicLogHandler is the interface of a logging http.Handler capable of turning on/off access log writing

EvWriter is a Writer which wants to know the original event of the []byte buffer (for filtering) Is has to also be a io.Writer, else it can't be used

Event reports named event with the upstream pool via a callback function. Currently named events: "quarantine", "retrying"

Event is the basic log event type. Exported to be able to implement Handler interface for external packages.

EventKeyNames holds keynames for fixed event fields, when needed (such as in JSON)

Factory is a function to create new connections.

-----

* * Providing tests like * https://www.freedesktop.org/software/systemd/man/sd_is_socket.html * */ FileTest is a function returning whether an *os.Fi

GaugeFloat64 is a float64 gauge which stores its value as a uint64 to implement FlushReading() fast (saving an interface allocation)

GaugeInt64 is a gauge using an int64 - meaning it can be decremented to negaive values

A client maintained gauge which is only sampled regularly without information loss wrt. the absolute value. Can be used as a client side maintained co

Handler is the interface needed to be a part of the Handler chain. Events are sent from a logger down a chain of Handlers. The final Handler (which d

HandlerOption is an option-function provided by the package of a Handler

Histogram is a series of int64 events all sent to the server

Hugorm is a prioritized configuration registry. It maintains a set of configuration sources, fetches values to populate those, and provides them accor

KV is a map of key/value pairs to pass to a Logger context or to a log function for structured logging. Value can be any stringable object, or a Value

KeyValues is a slice of interfaces alternating between key and value for data to be logged. Keys are at even numbered indexes and must be string. Valu

Lazy evaluation of values to log returns stringable objects

LevelLogger makes available methods compatible with the stdlib logger and an extended API for leveled logging. LevelLogger is implemented by *log.Logg

LingeringServer is a Server which potentially has background activity even after Serve() has exited. This could be connections still open and processi

Listener - Servers implementing the Listener interface will be called upon to Listen() before being asked to Serve()

ListenerGroup implement a gone/daemon/listen interface using the gone/sd library.

ListenerSpec describes the properties of a listener so it can be instantiated either via the "sd" library or directly from stdlib package "net"

ListeningServer is a Server which wished to have its Listen() method called before Serve()

LogFunc is the type of the function returned by *ok() methods, which will log at the level queried about if called.

Logable is the interface needed for an object to be provided as a value to a nil key and then being allowed to generate it's k/v log values it self by

Logger implements a stdlib *log.Logger source code compatible interface and extra methods for supporting leveled, structured and context logging. Don

A LoggerFunc can be set to make the daemon internal events log to a custom log library

A LoggerFunc can be set to make the library log to a custom log library

MConfig holds configuration state for metric clients. This is an internal type.

MandatorySubConfig implements the SubConfig interface which will return ErrEmptySubConfig if there is no JSON config. This can help catch mistakes in

Mappings map OS signals to functions

some implementors of io.Writer for use in Formatters MaybeTtyWriter is a writer which know whether the underlying writer is a TTY

Meter is a measurement instrument - a named metric. It measures stuff and can be registered with a client to be periodically reported to the Sink. Thi

MultiServer manages a slice of servers implementing the Serve interface (and possibly Listener/Waiter) The servers are started by calling Serve() and

NotReadyError is returned from a Serve() call if the server is already running, or during shutdown.

Numeric64 is an internal datatype used to generalize an eventStream to hold any 64 bit numeric value. This is a performance optimation. An interface{}

---------------------------------- OPTIONS ------------------------------

OptionalSubConfig implements the SubConfig interface and silently ignores being passed nil JSON values. Users of OptionalSubConfig will have to check

PacketListener - an object which can create a slice of PacketConn listeners when invoked

PinKeyFunc is a function which, based on a request, returns a string as a routing key for the request, to allow the Round Robin upstream to cache the

Pool interface describes a pool implementation. A pool should have maximum capacity. An ideal pool is threadsafe and easy to use.

PoolConn is a wrapper around net.Conn to modify the the behavior of net.Conn's Close() method.

Priority is the std library syslog.Priority type

RecordingResponseWriter is the interface of the recorder.

RoundTripContext is an object maintained by the virtual upstream implementation which is opaque to the VirtualTransport apart from the methods specifi

Server is the interface of objects daemon.Run() will manage. These objects will be single-use only with a lifetime: Listen, Serve, Shutdown, - and pos

Server is an server started by the master MultiServer, by calling Serve() which is expected to block until the server is signaled to stop by an invoca

Server wraps around gone/http/graceful HTTP server implementing gone/the daemon/srv.Server interface If ErrorLog is set, errors will be logged to it.

*heavily* inspired from https://github.com/tylerb/graceful But without the os.Signal stuff - KISS Server implements an extended http.Server with a Shu

Server wraps around gone/http/graceful HTTP server implementing gone/the daemon/srv.Server interface If ErrorLog is set, errors will be logged to it.

Server implements a server accepting connections on a UNIX domain socket on which registered commands can be invoked. The client connections to this s

----------------- The actual HTTP server ---------------------- maintaining a simple string as state. Server is an example server which can be manipul

Set is a not too efficient implementation of that statsd "set" concept. The client will send set membership notifications. Statsd will periodically fu

Sink is a sink for metrics data which methods need to be go-routine safe

Sink is a go-routine safe version of a Statsd sink. Call UnlockedSink() to get a faster, but not go-routine safe Sink.

--- StdFormatter allows quering a formatting handler for flags and prefix compatible with the stdlib log library

StdLogger is the interface used by the standard lib *log.Logger This is the API for actually logging stuff.

StdLoggerFull is mostly for documentation purposes. This is the full set of methods supported by the standard logger. You would only use the extra met

StdMutableFormatter is the interface for a Logger which directly can change the stdlib flags, prefix and output io.Writer attributes in a synchronized

--- StdlibAdapter wraps a Logger and allows it to be passed to the stdlib logger's SetOutput. It will extract date/timestamps, filenames, and messages