func TestCarbonInvalidCarbonDeconstructorListenerLoader(t *testing.T) { listenFrom := &config.ListenFrom{ ListenAddr: workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:12247"), MetricDeconstructor: workarounds.GolangDoesnotAllowPointerToStringLiteral("UNKNOWN"), } ctx := context.Background() forwardTo := dptest.NewBasicSink() _, err := ListenerLoader(ctx, forwardTo, listenFrom) assert.NotEqual(t, nil, err, "Should get an error making") }
func TestListenerLoader(t *testing.T) { listenFrom := &config.ListenFrom{ ListenAddr: workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:0"), ServerAcceptDeadline: workarounds.GolangDoesnotAllowPointerToTimeLiteral(time.Millisecond), } ctx := context.Background() forwardTo := dptest.NewBasicSink() listener, err := ListenerLoader(ctx, forwardTo, listenFrom) defer listener.Close() assert.Equal(t, nil, err, "Should be ok to make") defer listener.Close() listeningDialAddress := fmt.Sprintf("127.0.0.1:%d", nettest.TCPPort(listener.psocket)) assert.Equal(t, numStats, len(listener.Stats()), "Should have no stats") assert.NoError(t, err, "Should be ok to make") conn, err := net.Dial("tcp", listeningDialAddress) assert.NoError(t, err, "Should be ok to make") assert.Equal(t, int64(0), listener.stats.invalidDatapoints) var buf bytes.Buffer fmt.Fprintf(&buf, "%s %d %d\n\nINVALIDLINE", "ametric", 2, 2) _, err = buf.WriteTo(conn) conn.Close() assert.Equal(t, nil, err, "Should be ok to write") dp := forwardTo.Next() assert.Equal(t, "ametric", dp.Metric, "Should be metric") i := dp.Value.(datapoint.IntValue).Int() assert.Equal(t, int64(2), i, "Should get 2") for atomic.LoadInt64(&listener.stats.retriedListenErrors) == 0 { time.Sleep(time.Millisecond) } assert.Equal(t, int64(1), atomic.LoadInt64(&listener.stats.invalidDatapoints)) }
func TestCarbonHandleConnection(t *testing.T) { log.Info("START TestCarbonHandleConnection") defer log.Info("END TestCarbonHandleConnection") listenFrom := &config.ListenFrom{ ListenAddr: workarounds.GolangDoesnotAllowPointerToStringLiteral("localhost:0"), } ctx := context.Background() forwardTo := dptest.NewBasicSink() listener, err := ListenerLoader(ctx, forwardTo, listenFrom) defer listener.Close() listeningDialAddress := fmt.Sprintf("localhost:%d", nettest.TCPPort(listener.psocket)) conn, err := net.Dial("tcp", listeningDialAddress) assert.NoError(t, err) conn.Close() assert.Error(t, listener.handleConnection(conn)) conn, err = net.Dial("tcp", listeningDialAddress) assert.NoError(t, err) waitChan := make(chan struct{}) go func() { time.Sleep(time.Millisecond * 10) assert.NoError(t, conn.Close()) close(waitChan) }() <-waitChan for atomic.LoadInt64(&listener.stats.totalEOFCloses) == 0 { time.Sleep(time.Millisecond) } }
func TestInvalidPort(t *testing.T) { ft := config.ForwardTo{ Host: workarounds.GolangDoesnotAllowPointerToStringLiteral("zzfbdsaj_)__@#$%.zzzzzzzzzzz"), Port: workarounds.GolangDoesnotAllowPointerToUint16Literal(1), } _, err := ForwarderLoader(context.Background(), &ft) assert.NotEqual(t, nil, err, "Expect an error") }
func TestInvalidListen(t *testing.T) { listenFrom := &config.ListenFrom{ ListenAddr: workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:999999"), } sendTo := dptest.NewBasicSink() ctx := context.Background() _, err := ListenerLoader(ctx, sendTo, listenFrom) assert.Error(t, err) }
func TestForwarderLoaderOldVersion(t *testing.T) { forwardTo := config.ForwardTo{ FormatVersion: workarounds.GolangDoesnotAllowPointerToUintLiteral(1), DefaultAuthToken: workarounds.GolangDoesnotAllowPointerToStringLiteral("AUTH_TOKEN"), } ctx := context.Background() _, err := ForwarderLoader(ctx, &forwardTo) assert.NoError(t, err) }
func TestCarbonInvalidListenerLoader(t *testing.T) { ctx := context.Background() listenFrom := &config.ListenFrom{ ListenAddr: workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:999999"), } sendTo := dptest.NewBasicSink() _, err := ListenerLoader(ctx, sendTo, listenFrom) assert.NotEqual(t, nil, err, "Should get an error making") }
func TestNewProtobufDataPoint(t *testing.T) { protoDatapoint := &com_signalfx_metrics_protobuf.DataPoint{ Source: workarounds.GolangDoesnotAllowPointerToStringLiteral("asource"), Metric: workarounds.GolangDoesnotAllowPointerToStringLiteral("ametric"), Value: &com_signalfx_metrics_protobuf.Datum{IntValue: workarounds.GolangDoesnotAllowPointerToIntLiteral(2)}, Dimensions: []*com_signalfx_metrics_protobuf.Dimension{{ Key: workarounds.GolangDoesnotAllowPointerToStringLiteral("key"), Value: workarounds.GolangDoesnotAllowPointerToStringLiteral("value"), }}, } dp, err := NewProtobufDataPointWithType(protoDatapoint, com_signalfx_metrics_protobuf.MetricType_COUNTER) assert.Equal(t, "asource", dp.Dimensions["sf_source"], "Line should be invalid") assert.NoError(t, err) assert.Equal(t, datapoint.Count, dp.MetricType, "Line should be invalid") v := com_signalfx_metrics_protobuf.MetricType_CUMULATIVE_COUNTER protoDatapoint.MetricType = &v dp, err = NewProtobufDataPointWithType(protoDatapoint, com_signalfx_metrics_protobuf.MetricType_COUNTER) assert.NoError(t, err) assert.Equal(t, datapoint.Counter, dp.MetricType, "Line should be invalid") item := &BodySendFormatV2{ Metric: "ametric", Value: 3.0, } assert.Contains(t, item.String(), "ametric", "Should get metric name back") f, _ := ValueToValue(item.Value) assert.Equal(t, datapoint.NewFloatValue(3.0), f, "Should get value 3 back") item.Value = 3 i, _ := ValueToValue(item.Value) assert.Equal(t, datapoint.NewIntValue(3), i, "Should get value 3 back") item.Value = int64(3) ValueToValue(item.Value) item.Value = "abc" s, _ := ValueToValue(item.Value) assert.Equal(t, datapoint.NewStringValue("abc"), s, "Should get value abc back") item.Value = struct{}{} _, err = ValueToValue(item.Value) assert.Error(t, err) }
func TestForwarderLoaderDefaults(t *testing.T) { forwardTo := config.ForwardTo{ FormatVersion: workarounds.GolangDoesnotAllowPointerToUintLiteral(2), DefaultAuthToken: workarounds.GolangDoesnotAllowPointerToStringLiteral("AUTH_TOKEN"), } ctx := context.Background() forwarder, err := ForwarderLoader(ctx, &forwardTo) assert.Nil(t, err) defer forwarder.Close() }
func TestLoader(t *testing.T) { listenFrom := config.ListenFrom{} listenFrom.ListenAddr = workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:0") ctx := context.Background() forwardTo := dptest.NewBasicSink() l, err := ListenerLoader(ctx, forwardTo, &listenFrom) port := nettest.TCPPort(l.psocket) ft := config.ForwardTo{ Host: workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1"), Port: workarounds.GolangDoesnotAllowPointerToUint16Literal(port), } f, err := ForwarderLoader(context.Background(), &ft) assert.NoError(t, err) dpSent := dptest.DP() dpSent.Dimensions = map[string]string{} assert.NoError(t, f.AddDatapoints(ctx, []*datapoint.Datapoint{dpSent})) dpSeen := forwardTo.Next() assert.Equal(t, dpSent.Metric, dpSeen.Metric) assert.Equal(t, numStats+1, len(f.Stats())) }
func TestFilenameForwarderBadWrite(t *testing.T) { ctx := context.Background() fileObj, _ := ioutil.TempFile("", "gotest") defer os.Remove(fileObj.Name()) conf := &config.ForwardTo{ Filename: workarounds.GolangDoesnotAllowPointerToStringLiteral(fileObj.Name()), } f, _ := ForwarderLoader(conf) f.writeString = func(f *os.File, s string) (ret int, err error) { return 0, errors.New("nope") } assert.Error(t, f.AddDatapoints(ctx, []*datapoint.Datapoint{dptest.DP()})) assert.Error(t, f.AddEvents(ctx, []*event.Event{dptest.E()})) }
func TestFilenameForwarder(t *testing.T) { ctx := context.Background() fileObj, _ := ioutil.TempFile("", "gotest") filename := fileObj.Name() defer os.Remove(filename) conf := &config.ForwardTo{ Filename: workarounds.GolangDoesnotAllowPointerToStringLiteral(fileObj.Name()), } f, err := ForwarderLoader(conf) defer f.Close() assert.NoError(t, err) assert.NoError(t, f.AddDatapoints(ctx, []*datapoint.Datapoint{dptest.DP()})) assert.NoError(t, f.AddEvents(ctx, []*event.Event{dptest.E()})) assert.Equal(t, 0, len(f.Stats())) }
func setupServerForwarder(t *testing.T) (*dptest.BasicSink, *ListenerServer, *Forwarder) { // TODO: Break this out into smaller tests listenFromSignalfx := config.ListenFrom{} listenFromSignalfx.ListenAddr = workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:0") finalDatapointDestination := dptest.NewBasicSink() ctx := context.Background() l, err := ListenerLoader(ctx, finalDatapointDestination, &listenFromSignalfx) assert.Equal(t, nil, err, "Expect no error") port := nettest.TCPPort(l.listener) forwardTo := config.ForwardTo{ URL: workarounds.GolangDoesnotAllowPointerToStringLiteral(fmt.Sprintf("http://127.0.0.1:%d/v2/datapoint", port)), TimeoutDuration: workarounds.GolangDoesnotAllowPointerToDurationLiteral(time.Second * 1), DefaultAuthToken: workarounds.GolangDoesnotAllowPointerToStringLiteral("AUTH_TOKEN"), DefaultSource: workarounds.GolangDoesnotAllowPointerToStringLiteral("proxy-source"), SourceDimensions: workarounds.GolangDoesnotAllowPointerToStringLiteral("username,ignored,hostname"), } _, forwarder, err := ForwarderLoader1(ctx, &forwardTo) assert.NoError(t, err, "Expect no error") return finalDatapointDestination, l, forwarder }
func TestCreation(t *testing.T) { listenFrom := config.ListenFrom{} listenFrom.ListenAddr = workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:0") forwardTo := dptest.NewBasicSink() ctx := context.Background() l, err := ListenerLoader(ctx, forwardTo, &listenFrom) defer l.Close() assert.Equal(t, nil, err, "Expect no error") assert.Equal(t, numStats, len(l.Stats()), "Expect no stats") forwarder, err := NewForwarder("127.0.0.1", nettest.TCPPort(l.psocket), time.Second, []string{"zzfirst"}, 10) defer forwarder.Close() assert.Equal(t, nil, err, "Expect no error") assert.Equal(t, 1, len(forwarder.pool.conns)) timeToSend := time.Now().Round(time.Second) dpSent := dptest.DP() dpSent.Timestamp = timeToSend log.Info("Sending a dp") forwarder.AddDatapoints(ctx, []*datapoint.Datapoint{dpSent}) log.Info("Looking for DP back") dpSeen := forwardTo.Next() assert.Equal(t, "randtest."+dpSent.Metric, dpSeen.Metric, "Expect metric back") assert.Equal(t, dpSent.Timestamp, dpSeen.Timestamp, "Expect metric back") // Test creating a new connection if pool is empty for forwarder.pool.Get() != nil { } forwarder.AddDatapoints(ctx, []*datapoint.Datapoint{dpSent}) dpSeen = forwardTo.Next() assert.Equal(t, "randtest."+dpSent.Metric, dpSeen.Metric, "Expect metric back") assert.Equal(t, dpSent.Timestamp, dpSeen.Timestamp, "Expect metric back") // // Test creation error if pool is empty for forwarder.pool.Get() != nil { } forwarder.dialer = func(network, address string, timeout time.Duration) (net.Conn, error) { return nil, errors.New("nope") } assert.Error(t, forwarder.AddDatapoints(ctx, []*datapoint.Datapoint{dpSeen})) forwarder.dialer = net.DialTimeout assert.NoError(t, forwarder.AddDatapoints(ctx, []*datapoint.Datapoint{dpSeen}), "Should get the conn back") }
func TestCarbonNoWriteEvents(t *testing.T) { listenFrom := config.ListenFrom{} listenFrom.ListenAddr = workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:0") forwardTo := dptest.NewBasicSink() ctx := context.Background() l, err := ListenerLoader(ctx, forwardTo, &listenFrom) defer l.Close() assert.Equal(t, nil, err, "Expect no error") assert.Equal(t, numStats, len(l.Stats()), "Expect no stats") forwarder, err := NewForwarder("127.0.0.1", nettest.TCPPort(l.psocket), time.Second, []string{"zzfirst"}, 10) assert.Equal(t, nil, err, "Expect no error") assert.Equal(t, 1, len(forwarder.pool.conns)) timeToSend := time.Now().Round(time.Second) eSent := dptest.E() eSent.Timestamp = timeToSend eSent.Meta["blarg"] = "abcd 123 123" log.Info("Sending a e") forwarder.AddEvents(ctx, []*event.Event{eSent}) assert.Equal(t, 0, len(forwardTo.EventsChan)) }
func TestWriteError(t *testing.T) { listenFrom := config.ListenFrom{} listenFrom.ListenAddr = workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:0") forwardTo := dptest.NewBasicSink() ctx := context.Background() l, err := ListenerLoader(ctx, forwardTo, &listenFrom) defer l.Close() forwarder, err := NewForwarder("127.0.0.1", nettest.TCPPort(l.psocket), time.Second, []string{}, 10) assert.Equal(t, nil, err, "Expect no error") forwarder.dialer = func(network, address string, timeout time.Duration) (net.Conn, error) { mockConn := mockConn{} mockConn.writeReturn = errors.New("deadline error") return &mockConn, nil } for forwarder.pool.Get() != nil { } dpSent := dptest.DP() assert.Error(t, forwarder.AddDatapoints(ctx, []*datapoint.Datapoint{dpSent})) }
func TestCarbonWrite(t *testing.T) { listenFrom := config.ListenFrom{} listenFrom.ListenAddr = workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:0") forwardTo := dptest.NewBasicSink() ctx := context.Background() l, err := ListenerLoader(ctx, forwardTo, &listenFrom) defer l.Close() assert.Equal(t, nil, err, "Expect no error") assert.Equal(t, numStats, len(l.Stats()), "Expect no stats") forwarder, err := NewForwarder("127.0.0.1", nettest.TCPPort(l.psocket), time.Second, []string{"zzfirst"}, 10) assert.Equal(t, nil, err, "Expect no error") assert.Equal(t, 1, len(forwarder.pool.conns)) timeToSend := time.Now().Round(time.Second) dpSent := dptest.DP() dpSent.Timestamp = timeToSend dpSent.Meta[carbonNative] = "abcd 123 123" log.Info("Sending a dp") forwarder.AddDatapoints(ctx, []*datapoint.Datapoint{dpSent}) log.Info("Looking for DP back") dpSeen := forwardTo.Next() assert.Equal(t, "abcd", dpSeen.Metric, "Expect metric back") }
connectionAddress: connectionAddress, dialer: net.DialTimeout, pool: connPool{ conns: make([]net.Conn, 0, drainingThreads), }, } ret.pool.Return(conn) return ret, nil } var defaultForwarderConfig = &config.ForwardTo{ TimeoutDuration: workarounds.GolangDoesnotAllowPointerToTimeLiteral(time.Second * 30), BufferSize: workarounds.GolangDoesnotAllowPointerToUintLiteral(uint32(10000)), Port: workarounds.GolangDoesnotAllowPointerToUint16Literal(2003), DrainingThreads: workarounds.GolangDoesnotAllowPointerToUintLiteral(uint32(5)), Name: workarounds.GolangDoesnotAllowPointerToStringLiteral("carbonforwarder"), MaxDrainSize: workarounds.GolangDoesnotAllowPointerToUintLiteral(uint32(1000)), DimensionsOrder: []string{}, } var errRequiredHost = errors.New("carbon forwarder requires host config") // ForwarderLoader loads a carbon forwarder that is buffered func ForwarderLoader(ctx context.Context, forwardTo *config.ForwardTo) (protocol.Forwarder, error) { structdefaults.FillDefaultFrom(forwardTo, defaultForwarderConfig) if forwardTo.Host == nil { return nil, errRequiredHost } fwd, err := NewForwarder(*forwardTo.Host, *forwardTo.Port, *forwardTo.TimeoutDuration, forwardTo.DimensionsOrder, *forwardTo.DrainingThreads) if err != nil { return nil, err
"sync" log "github.com/Sirupsen/logrus" "github.com/cep21/gohelpers/structdefaults" "github.com/cep21/gohelpers/workarounds" "github.com/signalfx/golib/datapoint" "github.com/signalfx/golib/event" "github.com/signalfx/metricproxy/config" "github.com/signalfx/metricproxy/dp/dpsink" "github.com/signalfx/metricproxy/protocol" "golang.org/x/net/context" ) var csvDefaultConfig = &config.ForwardTo{ Filename: workarounds.GolangDoesnotAllowPointerToStringLiteral("datapoints.csv"), Name: workarounds.GolangDoesnotAllowPointerToStringLiteral("filename-drainer"), } // ForwarderLoader loads a CSV forwarder forwarding points from proxy to a file func ForwarderLoader(forwardTo *config.ForwardTo) (*FilenameForwarder, error) { structdefaults.FillDefaultFrom(forwardTo, csvDefaultConfig) log.WithField("forwardTo", forwardTo).Info("Creating CSV using final config") return NewForwarder(*forwardTo.Name, *forwardTo.Filename) } var _ protocol.Forwarder = &FilenameForwarder{} // FilenameForwarder prints datapoints to a file type FilenameForwarder struct { writeLock sync.Mutex
url string eventURL string defaultAuthToken string tr *http.Transport client *http.Client userAgent string defaultSource string dimensionSources []string emptyMetricNameFilter dpsink.EmptyMetricFilter protoMarshal func(pb proto.Message) ([]byte, error) jsonMarshal func(v interface{}) ([]byte, error) } var defaultConfigV2 = &config.ForwardTo{ URL: workarounds.GolangDoesnotAllowPointerToStringLiteral("https://ingest.signalfx.com/v2/datapoint"), EventURL: workarounds.GolangDoesnotAllowPointerToStringLiteral("https://api.signalfx.com/v1/event"), DefaultSource: workarounds.GolangDoesnotAllowPointerToStringLiteral(""), MetricCreationURL: workarounds.GolangDoesnotAllowPointerToStringLiteral(""), // Not used TimeoutDuration: workarounds.GolangDoesnotAllowPointerToTimeLiteral(time.Second * 60), BufferSize: workarounds.GolangDoesnotAllowPointerToUintLiteral(uint32(1000000)), DrainingThreads: workarounds.GolangDoesnotAllowPointerToUintLiteral(uint32(10)), Name: workarounds.GolangDoesnotAllowPointerToStringLiteral("signalfx-forwarder"), MaxDrainSize: workarounds.GolangDoesnotAllowPointerToUintLiteral(uint32(3000)), SourceDimensions: workarounds.GolangDoesnotAllowPointerToStringLiteral(""), FormatVersion: workarounds.GolangDoesnotAllowPointerToUintLiteral(uint32(3)), } // ForwarderLoader loads a json forwarder forwarding points from proxy to SignalFx func ForwarderLoader(ctx context.Context, forwardTo *config.ForwardTo) (protocol.Forwarder, error) { f, _, err := ForwarderLoader1(ctx, forwardTo)
func TestMetricTypeFromDsType(t *testing.T) { assert.Equal(t, datapoint.Gauge, metricTypeFromDsType(workarounds.GolangDoesnotAllowPointerToStringLiteral("gauge")), "Types don't match expectation") assert.Equal(t, datapoint.Gauge, metricTypeFromDsType(nil), "Types don't match expectation") assert.Equal(t, datapoint.Gauge, metricTypeFromDsType(workarounds.GolangDoesnotAllowPointerToStringLiteral("unknown")), "Types don't match expectation") assert.Equal(t, datapoint.Counter, metricTypeFromDsType(workarounds.GolangDoesnotAllowPointerToStringLiteral("derive")), "Types don't match expectation") }
defaultDims[key] = value } } return defaultDims } // Stats about this decoder, including how many datapoints it decoded func (decoder *JSONDecoder) Stats(dimensions map[string]string) []*datapoint.Datapoint { return []*datapoint.Datapoint{ datapoint.New("total_blank_dims", dimensions, datapoint.NewIntValue(decoder.TotalBlankDims), datapoint.Counter, time.Now()), datapoint.New("invalid_collectd_json", dimensions, datapoint.NewIntValue(decoder.TotalErrors), datapoint.Counter, time.Now()), } } var defaultCollectdConfig = &config.ListenFrom{ ListenAddr: workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:8081"), TimeoutDuration: workarounds.GolangDoesnotAllowPointerToTimeLiteral(time.Second * 30), ListenPath: workarounds.GolangDoesnotAllowPointerToStringLiteral("/post-collectd"), Name: workarounds.GolangDoesnotAllowPointerToStringLiteral("collectd"), JSONEngine: workarounds.GolangDoesnotAllowPointerToStringLiteral("native"), } // ListenerLoader loads a listener for collectd write_http protocol func ListenerLoader(ctx context.Context, sink dpsink.Sink, listenFrom *config.ListenFrom) (*ListenerServer, error) { structdefaults.FillDefaultFrom(listenFrom, defaultCollectdConfig) log.WithField("listenFrom", listenFrom).Info("Creating listener using final config") return StartListeningCollectDHTTPOnPort(ctx, sink, *listenFrom.ListenAddr, *listenFrom.ListenPath, *listenFrom.TimeoutDuration, *listenFrom.Name) } // StartListeningCollectDHTTPOnPort servers http collectd requests func StartListeningCollectDHTTPOnPort(ctx context.Context, sink dpsink.Sink,
} for _, jsonDatapoint := range datapoints { v, err := ValueToValue(jsonDatapoint.Value) if err != nil { log.WithField("err", err).Warn("Unable to get value for datapoint") } else { dp := datapoint.New(jsonDatapoint.Metric, jsonDatapoint.Dimensions, v, fromMT(com_signalfx_metrics_protobuf.MetricType(mt)), fromTs(jsonDatapoint.Timestamp)) dps = append(dps, dp) } } } return decoder.Sink.AddDatapoints(ctx, dps) } var defaultConfig = &config.ListenFrom{ ListenAddr: workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:12345"), TimeoutDuration: workarounds.GolangDoesnotAllowPointerToTimeLiteral(time.Second * 30), Name: workarounds.GolangDoesnotAllowPointerToStringLiteral("signalfxlistener"), JSONEngine: workarounds.GolangDoesnotAllowPointerToStringLiteral("native"), } // ListenerLoader loads a listener for signalfx protocol from config func ListenerLoader(ctx context.Context, sink dpsink.Sink, listenFrom *config.ListenFrom) (*ListenerServer, error) { structdefaults.FillDefaultFrom(listenFrom, defaultConfig) log.WithField("listenFrom", listenFrom).Info("Creating signalfx listener using final config") return StartServingHTTPOnPort(ctx, sink, *listenFrom.ListenAddr, *listenFrom.TimeoutDuration, *listenFrom.Name) } type jsonMarshalStub func(v interface{}) ([]byte, error)
if netErr, ok := err.(net.Error); ok { if netErr.Timeout() || netErr.Temporary() { atomic.AddInt64(&listener.stats.retriedListenErrors, 1) log.Debug("Timeout (or temp) waiting for connection. Expected, will continue") continue } } log.WithField("err", err).Info("Unable to accept a socket connection") return } go listener.handleConnection(conn) } } var defaultListenerConfig = &config.ListenFrom{ ListenAddr: workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:2003"), Name: workarounds.GolangDoesnotAllowPointerToStringLiteral("carbonlistener"), TimeoutDuration: workarounds.GolangDoesnotAllowPointerToTimeLiteral(time.Second * 30), MetricDeconstructor: workarounds.GolangDoesnotAllowPointerToStringLiteral(""), MetricDeconstructorOptions: workarounds.GolangDoesnotAllowPointerToStringLiteral(""), ServerAcceptDeadline: workarounds.GolangDoesnotAllowPointerToTimeLiteral(time.Second), } // ListenerLoader loads a listener for the carbon/graphite protocol from config func ListenerLoader(ctx context.Context, sink dpsink.Sink, listenFrom *config.ListenFrom) (*Listener, error) { structdefaults.FillDefaultFrom(listenFrom, defaultListenerConfig) conf := listenerConfig{ serverAcceptDeadline: *listenFrom.ServerAcceptDeadline, connectionTimeout: *listenFrom.TimeoutDuration, name: *listenFrom.Name, }