// CollectMetrics collects metrics for testing
func (f *Mock) CollectMetrics(mts []plugin.PluginMetricType) ([]plugin.PluginMetricType, error) {
for _, p := range mts {
log.Printf("collecting %+v", p)
}
rand.Seed(time.Now().UTC().UnixNano())
metrics := []plugin.PluginMetricType{}
for i := range mts {
if mts[i].Namespace()[2] == "*" {
hostname, _ := os.Hostname()
for j := 0; j < 10; j++ {
v := fmt.Sprintf("host%d", j)
data := randInt(65, 90)
mt := plugin.PluginMetricType{
Data_: data,
Namespace_: []string{"intel", "mock", v, "baz"},
Source_: hostname,
Timestamp_: time.Now(),
Labels_: mts[i].Labels(),
Version_: mts[i].Version(),
}
metrics = append(metrics, mt)
}
} else {
data := randInt(65, 90)
mts[i].Data_ = data
mts[i].Source_, _ = os.Hostname()
mts[i].Timestamp_ = time.Now()
metrics = append(metrics, mts[i])
}
}
return metrics, nil
}
func NewStorageDriver(driverName string) (storage.StorageDriver, error) {
var storageDriver storage.StorageDriver
var err error
// TODO(vmarmol): We shouldn't need the housekeeping interval here and it shouldn't be public.
samplesToCache := int(*argDbBufferDuration / *manager.HousekeepingInterval)
if samplesToCache < statsRequestedByUI {
// The UI requests the most recent 60 stats by default.
samplesToCache = statsRequestedByUI
}
switch driverName {
case "":
// empty string by default is the in memory store
fallthrough
case "memory":
storageDriver = memory.New(*argSampleSize, int(*argDbBufferDuration))
return storageDriver, nil
case "influxdb":
var hostname string
hostname, err = os.Hostname()
if err != nil {
return nil, err
}
storageDriver, err = influxdb.New(
hostname,
"stats",
*argDbName,
*argDbUsername,
*argDbPassword,
*argDbHost,
*argDbIsSecure,
*argDbBufferDuration,
// TODO(monnand): One hour? Or user-defined?
1*time.Hour,
)
glog.V(2).Infof("Caching %d recent stats in memory\n", samplesToCache)
storageDriver = cache.MemoryCache(samplesToCache, samplesToCache, storageDriver)
case "bigquery":
var hostname string
hostname, err = os.Hostname()
if err != nil {
return nil, err
}
storageDriver, err = bigquery.New(
hostname,
"cadvisor",
*argDbName,
1*time.Hour,
)
glog.V(2).Infof("Caching %d recent stats in memory\n", samplesToCache)
storageDriver = cache.MemoryCache(samplesToCache, samplesToCache, storageDriver)
default:
err = fmt.Errorf("Unknown database driver: %v", *argDbDriver)
}
if err != nil {
return nil, err
}
return storageDriver, nil
}
func eventWorker() {
go func() {
// a ticker channel to limit reloads to marathon, 1s is enough for now.
ticker := time.NewTicker(1 * time.Second)
for {
select {
case <-ticker.C:
<-eventqueue
start := time.Now()
err := reload()
elapsed := time.Since(start)
if err != nil {
log.Println("config update failed")
if config.Statsd != "" {
go func() {
hostname, _ := os.Hostname()
statsd.Counter(1.0, "nixy."+hostname+".reload.failed", 1)
}()
}
} else {
log.Printf("config update took %s\n", elapsed)
if config.Statsd != "" {
go func(elapsed time.Duration) {
hostname, _ := os.Hostname()
statsd.Counter(1.0, "nixy."+hostname+".reload.success", 1)
statsd.Timing(1.0, "nixy."+hostname+".reload.time", elapsed)
}(elapsed)
}
}
}
}
}()
}
func NewStorageDriver(driverName string) (*memory.InMemoryStorage, error) {
var storageDriver *memory.InMemoryStorage
var backendStorage storage.StorageDriver
var err error
// TODO(vmarmol): We shouldn't need the housekeeping interval here and it shouldn't be public.
samplesToCache := int(*argDbBufferDuration / *manager.HousekeepingInterval)
if samplesToCache < statsRequestedByUI {
// The UI requests the most recent 60 stats by default.
samplesToCache = statsRequestedByUI
}
switch driverName {
case "":
backendStorage = nil
case "influxdb":
var hostname string
hostname, err = os.Hostname()
if err != nil {
return nil, err
}
backendStorage, err = influxdb.New(
hostname,
"stats",
*argDbName,
*argDbUsername,
*argDbPassword,
*argDbHost,
*argDbIsSecure,
*argDbBufferDuration,
// TODO(monnand): One hour? Or user-defined?
1*time.Hour,
)
case "bigquery":
var hostname string
hostname, err = os.Hostname()
if err != nil {
return nil, err
}
backendStorage, err = bigquery.New(
hostname,
"cadvisor",
*argDbName,
1*time.Hour,
)
default:
err = fmt.Errorf("Unknown database driver: %v", *argDbDriver)
}
if err != nil {
return nil, err
}
glog.Infof("Caching %d recent stats in memory; using \"%v\" storage driver\n", samplesToCache, driverName)
storageDriver = memory.New(samplesToCache, samplesToCache, backendStorage)
return storageDriver, nil
}
func main() {
http.HandleFunc("/zk", getNodeInfo)
os.Hostname()
hostName, err := os.Hostname()
if err != nil {
panic(err)
}
errr := http.ListenAndServe(hostName+":"+config.HttpPort, nil)
if errr != nil {
panic(errr)
}
}
func main() {
c.Hostname, _ = os.Hostname()
for _, e := range os.Environ() {
pair := strings.Split(e, "=")
c.Env = append(c.Env, EnvVar{pair[0], pair[1]})
}
fmt.Println(c)
static := web.New()
static.Get("/static/*", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
http.Handle("/static/", static)
goji.Get("/", renderIndex)
// Setup our service export
host, _ := os.Hostname()
info := []string{"simple peer discovery test"}
service, _ := mdns.NewMDNSService(host, "_http._tcp", "", "", 8000, nil, info)
// Create the mDNS server, defer shutdown
fmt.Println("Creating mDNS server")
server, _ := mdns.NewServer(&mdns.Config{Zone: service})
defer server.Shutdown()
// Make a channel for results and start listening
peers := make(chan *mdns.ServiceEntry, 4)
go func() {
fmt.Println("Waiting for peers")
for entry := range peers {
known := false
for _, e := range c.Peers {
if entry.Name == e {
known = true
}
}
if known == false {
fmt.Println("Got new peer", entry.Name)
c.Peers = append(c.Peers, entry.Name)
}
}
}()
fmt.Println("Creating mDNS listener")
//mdns.Lookup("_googlecast._tcp", peers)
// this will panic without IF_MULTICAST, causing the program to exit
mdns.Lookup("_http._tcp", peers)
fmt.Println("Creating HTTP server")
goji.Serve() // port 8000 by default
close(peers)
}
func NewFileLogger(gzipEnabled bool, compressionLevel int, filenameFormat, topic string) (*FileLogger, error) {
if gzipEnabled && strings.Index(filenameFormat, "<GZIPREV>") == -1 {
return nil, errors.New("missing <GZIPREV> in filenameFormat")
}
hostname, err := os.Hostname()
if err != nil {
return nil, err
}
shortHostname := strings.Split(hostname, ".")[0]
identifier := shortHostname
if len(*hostIdentifier) != 0 {
identifier = strings.Replace(*hostIdentifier, "<SHORT_HOST>", shortHostname, -1)
identifier = strings.Replace(identifier, "<HOSTNAME>", hostname, -1)
}
filenameFormat = strings.Replace(filenameFormat, "<TOPIC>", topic, -1)
filenameFormat = strings.Replace(filenameFormat, "<HOST>", identifier, -1)
if gzipEnabled && !strings.HasSuffix(filenameFormat, ".gz") {
filenameFormat = filenameFormat + ".gz"
}
f := &FileLogger{
logChan: make(chan *Message, 1),
compressionLevel: compressionLevel,
filenameFormat: filenameFormat,
gzipEnabled: gzipEnabled,
ExitChan: make(chan int),
termChan: make(chan bool),
hupChan: make(chan bool),
}
return f, nil
}
func authTokenNote(num int) (string, error) {
n := os.Getenv("USER")
if n == "" {
n = os.Getenv("USERNAME")
}
if n == "" {
whoami := exec.Command("whoami")
whoamiOut, err := whoami.Output()
if err != nil {
return "", err
}
n = strings.TrimSpace(string(whoamiOut))
}
h, err := os.Hostname()
if err != nil {
return "", err
}
if num > 1 {
return fmt.Sprintf("hub for %s@%s %d", n, h, num), nil
}
return fmt.Sprintf("hub for %s@%s", n, h), nil
}
func buildHost() string {
h, err := os.Hostname()
if err != nil {
return "unknown-host"
}
return h
}
func startMetrics(appName, graphiteServer string) {
if graphiteServer == "" {
glog.Warningf("No metrics server specified.")
return
}
addr, err := net.ResolveTCPAddr("tcp", graphiteServer)
if err != nil {
glog.Fatalf("Unable to resolve metrics server address: %s", err)
}
// Get the hostname and create the app-prefix.
hostName, err := os.Hostname()
if err != nil {
glog.Fatalf("Unable to retrieve hostname: %s", err)
}
appPrefix := fmt.Sprintf("%s.%s", appName, strings.Replace(hostName, ".", "-", -1))
// Runtime metrics.
metrics.RegisterRuntimeMemStats(metrics.DefaultRegistry)
go metrics.CaptureRuntimeMemStats(metrics.DefaultRegistry, SAMPLE_PERIOD)
go graphite.Graphite(metrics.DefaultRegistry, SAMPLE_PERIOD, appPrefix, addr)
// Uptime.
uptimeGuage := metrics.GetOrRegisterGaugeFloat64("uptime", metrics.DefaultRegistry)
go func() {
startTime := time.Now()
uptimeGuage.Update(0)
for _ = range time.Tick(SAMPLE_PERIOD) {
uptimeGuage.Update(time.Since(startTime).Seconds())
}
}()
}
func init() {
// Set up builtin middlewarez
OnBeforeNotify(httpRequestMiddleware)
// Default configuration
Config.update(&Configuration{
APIKey: "",
Endpoint: "https://notify.bugsnag.com/",
Hostname: "",
AppVersion: "",
ReleaseStage: "",
ParamsFilters: []string{"password", "secret"},
// * for app-engine
ProjectPackages: []string{"main*"},
NotifyReleaseStages: nil,
Logger: log.New(os.Stdout, log.Prefix(), log.Flags()),
PanicHandler: defaultPanicHandler,
Transport: http.DefaultTransport,
})
hostname, err := os.Hostname()
if err == nil {
Config.Hostname = hostname
}
}
func getHostname() string {
hostname, err := os.Hostname()
if err != nil {
hostname = "hostname"
}
return hostname
}
func InitConfig() {
var err error
WorkDir, err = com.WorkDir()
if err != nil {
panic(err)
}
ConfigPath = path.Join(WorkDir, "conf")
Hostname, err := os.Hostname()
if err != nil {
panic(err)
}
fmt.Println(Hostname)
err = initHosts()
if err != nil {
panic(err)
}
fmt.Println(Cfg)
UserPath = path.Join(ConfigPath, Cfg.GetUserDir(Hostname))
fmt.Println(ConfigPath, UserPath)
InitServices()
}
func (*hostnameHandler) Handle(ctx context.Context, prev <-chan ql.Line, next chan<- ql.Line, config map[string]interface{}) error {
field := "hostname"
ok := true
fieldIface := config["field"]
if fieldIface != nil {
field, ok = fieldIface.(string)
if !ok {
log.Log(ctx).Warn("Could not parse hostname config, using field=hostname")
field = "hostname"
}
}
log.Log(ctx).Debug("Starting filter handler", "handler", "hostname", "field", field)
hostname, _ := os.Hostname()
go func() {
for {
select {
case line := <-prev:
line.Data[field] = hostname
next <- line
case <-ctx.Done():
return
}
}
}()
return nil
}
func (cfg *Configuration) prepare(myID protocol.DeviceID) error {
var myName string
// Ensure this device is present in the config
for _, device := range cfg.Devices {
if device.DeviceID == myID {
goto found
}
}
myName, _ = os.Hostname()
cfg.Devices = append(cfg.Devices, DeviceConfiguration{
DeviceID: myID,
Name: myName,
})
found:
if err := cfg.clean(); err != nil {
return err
}
// Ensure that we are part of the devices
for i := range cfg.Folders {
cfg.Folders[i].Devices = ensureDevicePresent(cfg.Folders[i].Devices, myID)
}
return nil
}
// HostnameGroupingKey returns a label map with the only entry
// {instance="<hostname>"}. This can be conveniently used as the grouping
// parameter if metrics should be pushed with the hostname as label. The
// returned map is created upon each call so that the caller is free to add more
// labels to the map.
func HostnameGroupingKey() map[string]string {
hostname, err := os.Hostname()
if err != nil {
return map[string]string{"instance": "unknown"}
}
return map[string]string{"instance": hostname}
}
func loadHostName() string {
hostname, err := os.Hostname()
if err != nil {
hostname = "unknown"
}
return hostname
}
// DeleteNetwork deletes a network by named identifier
func (d *OvsDriver) DeleteNetwork(id, nwType, encap string, pktTag, extPktTag int, gateway string, tenant string) error {
log.Infof("delete net %s, nwType %s, encap %s, tags: %d/%d", id, nwType, encap, pktTag, extPktTag)
// Find the switch based on network type
var sw *OvsSwitch
if encap == "vxlan" {
sw = d.switchDb["vxlan"]
} else {
sw = d.switchDb["vlan"]
}
// Delete infra nw endpoint if present
if nwType == "infra" {
hostName, _ := os.Hostname()
epID := id + "-" + hostName
epOper := OvsOperEndpointState{}
epOper.StateDriver = d.oper.StateDriver
err := epOper.Read(epID)
if err == nil {
err = sw.DeletePort(&epOper, true)
if err != nil {
log.Errorf("Error deleting endpoint: %+v. Err: %v", epOper, err)
}
epOper.Clear()
}
}
return sw.DeleteNetwork(uint16(pktTag), uint32(extPktTag), gateway, tenant)
}
func init() {
var err error
hostname, err = os.Hostname()
if err != nil {
panic(fmt.Sprintf("kite: cannot get hostname: %s", err.Error()))
}
}
// Stale returns true if the lock is stale. A lock is stale if the timestamp is
// older than 30 minutes or if it was created on the current machine and the
// process isn't alive any more.
func (l *Lock) Stale() bool {
debug.Log("testing if lock %v for process %d is stale", l, l.PID)
if time.Since(l.Time) > staleTimeout {
debug.Log("lock is stale, timestamp is too old: %v\n", l.Time)
return true
}
hn, err := os.Hostname()
if err != nil {
debug.Log("unable to find current hostnanme: %v", err)
// since we cannot find the current hostname, assume that the lock is
// not stale.
return false
}
if hn != l.Hostname {
// lock was created on a different host, assume the lock is not stale.
return false
}
// check if we can reach the process retaining the lock
exists := l.processExists()
if !exists {
debug.Log("could not reach process, %d, lock is probably stale\n", l.PID)
return true
}
debug.Log("lock not stale\n")
return false
}
// Currently makes a linux kill file.
func MakeKillFile() error {
err := os.RemoveAll(KILLFILE_PATH)
if err != nil {
return err
}
file, err2 :=
os.OpenFile(
KILLFILE_PATH,
os.O_CREATE|
os.O_APPEND|
os.O_RDWR,
0744)
defer file.Close()
if err2 != nil {
return err2
}
_, err = fmt.Fprintln(file, "#!/bin/bash")
if err != nil {
fmt.Println("Problem creating the kill file: ", err)
return err
}
host, _ := os.Hostname()
pid := os.Getpid()
fmt.Fprintf(file, "# host %s\n", host)
fmt.Fprintf(file, "pkill -SIGKILL -P %d # Terminate subprocesses\n", pid)
_, err = fmt.Fprintf(file, "kill -SIGKILL %d # Terminate parent\n", pid)
return err
}
func mustHostname() string {
hostname, err := os.Hostname()
if err != nil {
panic(err)
}
return hostname
}
func TestDeviceAddressesStatic(t *testing.T) {
name, _ := os.Hostname()
expected := map[protocol.DeviceID]DeviceConfiguration{
device1: {
DeviceID: device1,
Addresses: []string{"tcp://192.0.2.1", "tcp://192.0.2.2"},
},
device2: {
DeviceID: device2,
Addresses: []string{"tcp://192.0.2.3:6070", "tcp://[2001:db8::42]:4242"},
},
device3: {
DeviceID: device3,
Addresses: []string{"tcp://[2001:db8::44]:4444", "tcp://192.0.2.4:6090"},
},
device4: {
DeviceID: device4,
Name: name, // Set when auto created
Addresses: []string{"dynamic"},
Compression: protocol.CompressMetadata,
},
}
cfg, err := Load("testdata/deviceaddressesstatic.xml", device4)
if err != nil {
t.Error(err)
}
actual := cfg.Devices()
if diff, equal := messagediff.PrettyDiff(expected, actual); !equal {
t.Errorf("Devices differ. Diff:\n%s", diff)
}
}
// ServerInfo - get server info.
func (web *webAPIHandlers) ServerInfo(r *http.Request, args *WebGenericArgs, reply *ServerInfoRep) error {
if !isJWTReqAuthenticated(r) {
return toJSONError(errAuthentication)
}
host, err := os.Hostname()
if err != nil {
host = ""
}
memstats := &runtime.MemStats{}
runtime.ReadMemStats(memstats)
mem := fmt.Sprintf("Used: %s | Allocated: %s | Used-Heap: %s | Allocated-Heap: %s",
humanize.Bytes(memstats.Alloc),
humanize.Bytes(memstats.TotalAlloc),
humanize.Bytes(memstats.HeapAlloc),
humanize.Bytes(memstats.HeapSys))
platform := fmt.Sprintf("Host: %s | OS: %s | Arch: %s",
host,
runtime.GOOS,
runtime.GOARCH)
goruntime := fmt.Sprintf("Version: %s | CPUs: %s", runtime.Version(), strconv.Itoa(runtime.NumCPU()))
reply.MinioEnvVars = os.Environ()
reply.MinioVersion = Version
reply.MinioMemory = mem
reply.MinioPlatform = platform
reply.MinioRuntime = goruntime
reply.UIVersion = miniobrowser.UIVersion
return nil
}
// Handle writes the error from the context into the HttpResponseWriter with a
// 500 http.StatusInternalServerError status code.
func (h *DefaultErrorHandler) Handle(ctx context.Context) (stop bool, err error) {
var handlerError HandlerError = ctx.Data().Get(DataKeyForError).(HandlerError)
hostname, _ := os.Hostname()
w := ctx.HttpResponseWriter()
// write the error out
w.Header().Set("Content-Type", "text/html")
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("<!DOCTYPE html><html><head>"))
w.Write([]byte("<style>"))
w.Write([]byte("h1 { font-size: 17px }"))
w.Write([]byte("h1 strong {text-decoration:underline}"))
w.Write([]byte("h2 { background-color: #ffd; padding: 20px }"))
w.Write([]byte("footer { margin-top: 20px; border-top:1px solid black; padding:10px; font-size:0.9em }"))
w.Write([]byte("</style>"))
w.Write([]byte("</head><body>"))
w.Write([]byte(fmt.Sprintf("<h1>Error in <code>%s</code></h1><h2>%s</h2>", handlerError.Handler, handlerError)))
w.Write([]byte(fmt.Sprintf("<h3><code>%s</code> error in Handler <code>%v</code></h3> <code><pre>%s</pre></code>", reflect.TypeOf(handlerError.OriginalError), &handlerError.Handler, handlerError.Handler)))
w.Write([]byte(fmt.Sprintf("on %s", hostname)))
w.Write([]byte("<footer>Learn more about <a href='http://github.com/stretchr/goweb' target='_blank'>Goweb</a></footer>"))
w.Write([]byte("</body></html>"))
// responses are actually ignored
return false, nil
}
// NewReader creates a new instance of Reader for the specified topic/channel
//
// The returned Reader instance is setup with sane default values. To modify
// configuration, update the values on the returned instance before connecting.
func NewReader(topic string, channel string) (*Reader, error) {
if !IsValidTopicName(topic) {
return nil, errors.New("invalid topic name")
}
if !IsValidChannelName(channel) {
return nil, errors.New("invalid channel name")
}
hostname, err := os.Hostname()
if err != nil {
log.Fatalf("ERROR: unable to get hostname %s", err.Error())
}
q := &Reader{
TopicName: topic,
ChannelName: channel,
incomingMessages: make(chan *incomingMessage),
ExitChan: make(chan int),
nsqConnections: make(map[string]*nsqConn),
MaxAttemptCount: 5,
LookupdPollInterval: 120 * time.Second,
lookupdExitChan: make(chan int),
lookupdRecheckChan: make(chan int, 1), // used at connection close to force a possible reconnect
DefaultRequeueDelay: 90 * time.Second,
MaxRequeueDelay: 15 * time.Minute,
ShortIdentifier: strings.Split(hostname, ".")[0],
LongIdentifier: hostname,
ReadTimeout: DefaultClientTimeout,
WriteTimeout: time.Second,
maxInFlight: 1,
}
q.SetMaxBackoffDuration(120 * time.Second)
return q, nil
}
// GET /info
func getInfo(c *context, w http.ResponseWriter, r *http.Request) {
info := dockerclient.Info{
Containers: int64(len(c.cluster.Containers())),
Images: int64(len(c.cluster.Images().Filter(cluster.ImageFilterOptions{}))),
DriverStatus: c.statusHandler.Status(),
NEventsListener: int64(c.eventsHandler.Size()),
Debug: c.debug,
MemoryLimit: true,
SwapLimit: true,
IPv4Forwarding: true,
BridgeNfIptables: true,
BridgeNfIp6tables: true,
NCPU: c.cluster.TotalCpus(),
MemTotal: c.cluster.TotalMemory(),
HttpProxy: os.Getenv("http_proxy"),
HttpsProxy: os.Getenv("https_proxy"),
NoProxy: os.Getenv("no_proxy"),
SystemTime: time.Now().Format(time.RFC3339Nano),
}
if hostname, err := os.Hostname(); err == nil {
info.Name = hostname
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(info)
}
func HostInfo() (*HostInfoStat, error) {
ret := &HostInfoStat{
OS: runtime.GOOS,
}
hostname, err := os.Hostname()
if err == nil {
ret.Hostname = hostname
}
platform, family, version, err := GetPlatformInformation()
if err == nil {
ret.Platform = platform
ret.PlatformFamily = family
ret.PlatformVersion = version
} else {
return ret, err
}
ret.Uptime, err = BootTime()
if err != nil {
return ret, err
}
procs, err := process.Pids()
if err != nil {
return ret, err
}
ret.Procs = uint64(len(procs))
return ret, nil
}
// OtherSystemInfo retrieves information from the system like hostname, IPv4 address, pagesize,
// target architecture and target operating system.
func OtherSystemInfo() map[string]string {
otherInfoMap := make(map[string]string)
// Hostname
hostname, err := os.Hostname()
if err != nil {
otherInfoMap["hostname"] = "Error: The hostname for the current system could not be retrieved."
} else {
otherInfoMap["hostname"] = hostname
}
// IP address
addresses, err := net.LookupHost(hostname)
if err != nil {
otherInfoMap["ipv4_address"] = "Error: The IPv4 address for the current system could not be retrieved."
} else {
for _, address := range addresses {
ipv4_address := net.ParseIP(address).To4()
if ipv4_address != nil {
otherInfoMap["ipv4_address"] = address
}
}
}
otherInfoMap["os_pagesize"] = strconv.Itoa(os.Getpagesize())
otherInfoMap["target_architecture"] = runtime.GOARCH
otherInfoMap["target_os"] = runtime.GOOS
return otherInfoMap
}
func main() {
hostname, err := os.Hostname()
if err != nil {
hostname = "unknown"
}
flag.StringVar(&prefix, "p", fmt.Sprintf("bucky-pickle-relay.%s", hostname),
"Prefix for internally generated metrics.")
flag.StringVar(&bindTo, "b", ":2004",
"Address to bind to for incoming connections.")
flag.BoolVar(&debug, "d", false,
"Debug mode.")
flag.IntVar(&pickleTimeout, "t", 300,
"Timeout in seconds on incoming pickle protocol TCP connections.")
flag.IntVar(&sendTimeout, "s", 30,
"TCP timeout in seconds for outgoing line protocol connections.")
flag.IntVar(&maxPickleSize, "x", 1*1024*1024,
"Maximum pickle size accepted.")
flag.IntVar(&pickleQueueSize, "q", 0,
"Internal buffer sizes.")
flag.DurationVar(&metricInterval, "i", 60,
"Interval in seconds between reporting of internal metrics.")
flag.Parse()
if flag.NArg() != 1 {
usage()
}
log.Printf("bucky-pickle-relay Copyright 2015 42 Lines, Inc.")
carbonRelay = flag.Arg(0)
log.Printf("Sending line protocol data to %s", carbonRelay)
log.Printf("Reporting internal metrics under %s", prefix)
metrics := serveForever()
plainTextOut(metrics)
}