func newCounterAndMockWriter() (*batch.DroppedCounter, *mockBatchChainByteWriter) { byteWriter := newMockBatchChainByteWriter() conf := &config.Config{ Deployment: "some-deployment", Job: "some-job", Index: "some-index", } counter := batch.NewDroppedCounter(byteWriter, newMockBatchCounterIncrementer(), origin, "some-ip", conf) return counter, byteWriter }
func initializeDopplerPool(conf *config.Config, batcher *metricbatcher.MetricBatcher, logger *gosteno.Logger) (*eventmarshaller.EventMarshaller, error) { adapter, err := storeAdapterProvider(conf) if err != nil { return nil, err } backoffStrategy := retrystrategy.Exponential() err = backoff.Connect(adapter, backoffStrategy, logger, connectionRetries) if err != nil { return nil, err } var protocols []string clientPool := make(map[string]clientreader.ClientPool) writers := make(map[string]eventmarshaller.BatchChainByteWriter) ip, err := localip.LocalIP() if err != nil { return nil, err } for protocol := range conf.Protocols { proto := string(protocol) protocols = append(protocols, proto) switch proto { case "udp": udpCreator := clientpool.NewUDPClientCreator(logger) udpWrapper := dopplerforwarder.NewUDPWrapper([]byte(conf.SharedSecret), logger) udpPool := clientpool.NewDopplerPool(logger, udpCreator) udpForwarder := dopplerforwarder.New(udpWrapper, udpPool, logger) clientPool[proto] = udpPool writers[proto] = udpForwarder case "tcp": tcpCreator := clientpool.NewTCPClientCreator(logger, nil) tcpWrapper := dopplerforwarder.NewWrapper(logger, proto) tcpPool := clientpool.NewDopplerPool(logger, tcpCreator) tcpForwarder := dopplerforwarder.New(tcpWrapper, tcpPool, logger) tcpBatchInterval := time.Duration(conf.TCPBatchIntervalMilliseconds) * time.Millisecond dropCounter := batch.NewDroppedCounter(tcpForwarder, batcher, origin, ip, conf) batchWriter, err := batch.NewWriter( "tcp", tcpForwarder, dropCounter, conf.TCPBatchSizeBytes, tcpBatchInterval, logger, ) if err != nil { return nil, err } clientPool[proto] = tcpPool writers[proto] = batchWriter case "tls": c := conf.TLSConfig tlsConfig, err := listeners.NewTLSConfig(c.CertFile, c.KeyFile, c.CAFile) if err != nil { return nil, err } tlsConfig.ServerName = "doppler" tlsCreator := clientpool.NewTCPClientCreator(logger, tlsConfig) tlsWrapper := dopplerforwarder.NewWrapper(logger, proto) tlsPool := clientpool.NewDopplerPool(logger, tlsCreator) tlsForwarder := dopplerforwarder.New(tlsWrapper, tlsPool, logger) tcpBatchInterval := time.Duration(conf.TCPBatchIntervalMilliseconds) * time.Millisecond dropCounter := batch.NewDroppedCounter(tlsForwarder, batcher, origin, ip, conf) batchWriter, err := batch.NewWriter( "tls", tlsForwarder, dropCounter, conf.TCPBatchSizeBytes, tcpBatchInterval, logger, ) if err != nil { return nil, err } clientPool[proto] = tlsPool writers[proto] = batchWriter } } finder := dopplerservice.NewFinder(adapter, conf.LoggregatorDropsondePort, conf.Protocols.Strings(), conf.Zone, logger) finder.Start() marshaller := eventmarshaller.New(batcher, logger) go func() { for { protocol := clientreader.Read(clientPool, conf.Protocols.Strings(), finder.Next()) logger.Infof("Chose protocol %s from last etcd event, updating writer...", protocol) marshaller.SetWriter(writers[protocol]) } }() return marshaller, nil }
Expect(actualCounter.GetOrigin()).To(Equal(origin)) Expect(actualCounter.EventType).To(Equal(events.Envelope_CounterEvent.Enum())) Expect(actualCounter.CounterEvent.GetName()).To(ContainSubstring("DroppedCounter.droppedMessageCount")) Expect(actualCounter.CounterEvent.GetDelta()).To(BeNumerically("==", 5)) actualLog := actualEnvelopes[1] Expect(actualLog.GetOrigin()).To(Equal(origin)) Expect(actualLog.EventType).To(Equal(events.Envelope_LogMessage.Enum())) Expect(actualLog.LogMessage.Message).To(ContainSubstring("Dropped 5 message(s) from MetronAgent to Doppler")) }) It("retries sending messages when sending errors", func() { incrementer := newMockBatchCounterIncrementer() byteWriter := newMockBatchChainByteWriter() counter := batch.NewDroppedCounter(byteWriter, incrementer, origin, "some-ip", new(config.Config)) byteWriter.WriteOutput.SentLength <- 0 byteWriter.WriteOutput.Err <- errors.New("boom") counter.Drop(20) Eventually(incrementer.BatchIncrementCounterInput).Should(BeCalled( With("droppedCounter.sendErrors"), )) Expect(byteWriter.WriteInput.Message).To(Receive()) var messages []byte Eventually(byteWriter.WriteInput.Message).Should(Receive(&messages)) actualEnvelopes, err := unmarshalMessages(messages)