statsgod

type Auth interface {
	// Authenticate takes a metric string and authenticates it. The metric
	// is passed by reference in case the Auth object needs to manipulate
	// it, such as removing a token.
	Authenticate(metric *string) (bool, error)
}

type AuthConfigToken struct {
	// Tokens contains a list of valid auth tokens with a token as the key
	// which maps to a boolean defining the validity of the token.
	Tokens map[string]bool
}

type AuthNone struct {
}

type CarbonRelay struct {
	FlushInterval  time.Duration
	Percentile     []int
	ConnectionPool *ConnectionPool
	Prefixes       map[int]string
	Suffixes       map[int]string
}

type ConfigValues struct {
	Service struct {
		Name     string
		Debug    bool
		Auth     string
		Tokens   map[string]bool
		Hostname string
	}
	Connection struct {
		Tcp struct {
			Enabled bool
			Host    string
			Port    int
		}
		Udp struct {
			Enabled   bool
			Host      string
			Port      int
			Maxpacket int
		}
		Unix struct {
			Enabled bool
			File    string
		}
	}
	Relay struct {
		Type        string
		Concurrency int
		Timeout     time.Duration
		Flush       time.Duration
	}
	Namespace struct {
		Prefix   string
		Prefixes struct {
			Counters string
			Gauges   string
			Rates    string
			Sets     string
			Timers   string
		}
		Suffix   string
		Suffixes struct {
			Counters string
			Gauges   string
			Rates    string
			Sets     string
			Timers   string
		}
	}
	Carbon struct {
		Host string
		Port int
	}
	Stats struct {
		Percentile []int
	}
	Debug struct {
		Verbose bool
		Receipt bool
		Profile bool
		Relay   bool
	}
}

type ConnectionPool struct {
	// Size indicates the number of connections to keep open.
	Size int
	// Connections is the channel to push new/reused connections onto.
	Connections chan net.Conn
	// Addr is the string representing the address of the socket.
	Addr string
	// Type is the type of connection the pool will make.
	Type int
	// Timeout is the amount of time to wait for a connection.
	Timeout time.Duration
	// ErrorCount tracks the number of connection errors that have occured.
	ErrorCount int
}

type Logger struct {
	// Trace log level.
	Trace *log.Logger
	// Info log level.
	Info *log.Logger
	// Warning log level.
	Warning *log.Logger
	// Error log level.
	Error *log.Logger
}

type Metric struct {
	Key             string           // Name of the metric.
	MetricType      int              // What type of metric is it (gauge, counter, timer)
	TotalHits       float64          // Number of times it has been used.
	LastValue       float64          // The last value stored.
	ValuesPerSecond float64          // The number of values per second.
	MinValue        float64          // The min value.
	MaxValue        float64          // The max value.
	MeanValue       float64          // The cumulative mean.
	MedianValue     float64          // The cumulative median.
	Quantiles       []MetricQuantile // A list of quantile calculations.
	AllValues       ValueSlice       // All of the values.
	FlushTime       int              // What time are we sending Graphite?
	LastFlushed     int              // When did we last flush this out?
	SampleRate      float64          // The sample rate of the metric.
}

type MetricQuantile struct {
	Quantile  int        // The specified percentile.
	Boundary  float64    // The calculated quantile value.
	AllValues ValueSlice // All of the values.
	Mean      float64    // The mean value within the quantile.
	Median    float64    // The median value within the quantile.
	Max       float64    // The maxumum value within the quantile.
	Sum       float64    // The sum value within the quantile.
}

type MetricRelay interface {
	Relay(metric Metric, logger Logger) bool
}

type MockRelay struct {
	FlushInterval time.Duration
	Percentile    []int
}

type NilConn struct{}

type Socket interface {
	Listen(parseChannel chan string, logger Logger, config *ConfigValues)
	Close(logger Logger)
	GetAddr() string
	SocketIsActive() bool
}

type SocketTcp struct {
	Addr     string
	Listener net.Listener
}

type SocketUdp struct {
	Addr     string
	Listener *net.UDPConn
}

type SocketUnix struct {
	Addr     string
	Listener net.Listener
}

type ValueSlice []float64