func main() { runtime.GOMAXPROCS(4) var interval = flag.String("interval", "1s", "Interval for reported results") var writeRate = flag.Int("writeRate", 15000, "Number of writes per second to send to metron") var stopAfter = flag.String("stopAfter", "5m", "How long to run the experiment for") flag.Parse() duration, err := time.ParseDuration(*interval) if err != nil { log.Fatalf("Invalid duration %s\n", *interval) } stopAfterDuration, err := time.ParseDuration(*stopAfter) if err != nil { log.Fatalf("Invalid duration %s\n", *stopAfter) } internalMetricsCounter := metricsreporter.NewCounter("internal metrics") reporter := metricsreporter.New(duration, os.Stdout, internalMetricsCounter) reader := messagereader.NewMessageReader(3457) legacyReader := legacyreader.NewLegacyReader(reporter.GetReceivedCounter(), internalMetricsCounter, reader) exp := experiment.NewExperiment(legacyReader) generator := messagegenerator.NewValueMetricGenerator() writer := messagewriter.NewMessageWriter("localhost", 51161, "", reporter.GetSentCounter()) writeStrategy := writestrategies.NewConstantWriteStrategy(generator, writer, *writeRate) exp.AddWriteStrategy(writeStrategy) legacyGenerator := messagegenerator.NewLegacyLogGenerator() legacyWriter := messagewriter.NewMessageWriter("localhost", 51160, "", reporter.GetSentCounter()) legacyWriteStrategy := writestrategies.NewConstantWriteStrategy(legacyGenerator, legacyWriter, *writeRate) exp.AddWriteStrategy(legacyWriteStrategy) announceToEtcd() go reporter.Start() go exp.Start() timer := time.NewTimer(stopAfterDuration) <-timer.C exp.Stop() reporter.Stop() }
func NewFakeApp(appID string, warmupRate int, logRate int) *FakeApp { generator := messagegenerator.NewLogMessageGenerator(appID) counter := metricsreporter.NewCounter("sentLogs") // 49625 is the DropsondeIncomingMessagesPort for the metron that will be spun up. writer := messagewriter.NewMessageWriter("localhost", 49625, "", counter) writeStrategy := writestrategies.NewConstantWriteStrategy(generator, writer, logRate) warmupStrategy := writestrategies.NewConstantWriteStrategy(generator, writer, warmupRate) return &FakeApp{ appID: appID, logRate: logRate, writeStrategy: writeStrategy, warmupStrategy: warmupStrategy, logCounter: counter, } }
func chooseStrategy(generator writestrategies.MessageGenerator, writer writestrategies.MessageWriter, writeRate int, burstDelay time.Duration) experiment.WriteStrategy { if burstDelay > 0 { params := writestrategies.BurstParameters{ Minimum: writeRate, Maximum: writeRate, Frequency: burstDelay, } return writestrategies.NewBurstWriteStrategy(generator, writer, params) } return writestrategies.NewConstantWriteStrategy(generator, writer, writeRate) }
func main() { runtime.GOMAXPROCS(4) var interval = flag.String("interval", "1s", "Interval for reported results") var writeRate = flag.Int("writeRate", 15000, "Number of writes per second to send to doppler") var stopAfter = flag.String("stopAfter", "5m", "How long to run the experiment for") var sharedSecret string flag.StringVar(&sharedSecret, "sharedSecret", "", "Shared secret used by Doppler to verify message validity") var dopplerOutgoingPort = flag.Int("dopplerOutgoingPort", 8080, "Outgoing port from doppler") var dopplerIncomingDropsondePort = flag.Int("dopplerIncomingDropsondePort", 3457, "Incoming dropsonde port to doppler") flag.Parse() duration, err := time.ParseDuration(*interval) if err != nil { log.Fatalf("Invalid duration %s\n", *interval) } stopAfterDuration, err := time.ParseDuration(*stopAfter) if err != nil { log.Fatalf("Invalid duration %s\n", *stopAfter) } reporter := metricsreporter.New(duration, os.Stdout) ip, err := localip.LocalIP() if err != nil { panic(err) } generator := messagegenerator.NewValueMetricGenerator() writer := messagewriter.NewMessageWriter(ip, *dopplerIncomingDropsondePort, sharedSecret, reporter.SentCounter()) reader := websocketmessagereader.New(fmt.Sprintf("%s:%d", ip, *dopplerOutgoingPort), reporter.ReceivedCounter()) defer reader.Close() writeStrategy := writestrategies.NewConstantWriteStrategy(generator, writer, *writeRate) exp := experiment.NewExperiment(reader) exp.AddWriteStrategy(writeStrategy) exp.Warmup() go reporter.Start() go exp.Start() timer := time.NewTimer(stopAfterDuration) <-timer.C exp.Stop() reporter.Stop() }
func main() { runtime.GOMAXPROCS(runtime.NumCPU()) var interval = flag.String("interval", "1s", "Interval for reported results") var writeRate = flag.Int("writeRate", 15000, "Number of writes per second to send to metron") var stopAfter = flag.String("stopAfter", "5m", "How long to run the experiment for") var concurrentWriters = flag.Int("concurrentWriters", 1, "Number of concurrent writers") flag.Parse() duration, err := time.ParseDuration(*interval) if err != nil { log.Fatalf("Invalid duration %s\n", *interval) } stopAfterDuration, err := time.ParseDuration(*stopAfter) if err != nil { log.Fatalf("Invalid duration %s\n", *stopAfter) } reporter := metricsreporter.New(duration, os.Stdout) generator := messagegenerator.NewValueMetricGenerator() reader := messagereader.NewMessageReader(3457) valueMetricReader := valuemetricreader.NewValueMetricReader(reporter.GetReceivedCounter(), reader) exp := experiment.NewExperiment(valueMetricReader) for i := 0; i < *concurrentWriters; i++ { writer := messagewriter.NewMessageWriter("localhost", 51161, "", reporter.GetSentCounter()) writeStrategy := writestrategies.NewConstantWriteStrategy(generator, writer, *writeRate) exp.AddWriteStrategy(writeStrategy) } announceToEtcd() exp.Warmup() go reporter.Start() go exp.Start() timer := time.NewTimer(stopAfterDuration) <-timer.C exp.Stop() reporter.Stop() }
. "github.com/onsi/gomega" ) var _ = Describe("WriteStrategies", func() { Context("ConstantWriteStrategy", func() { Describe("StartWriter", func() { var ( writer mockWriter stopChan chan struct{} writeStrategy *writestrategies.ConstantWriteStrategy ) BeforeEach(func() { writer = mockWriter{} stopChan = make(chan struct{}) writeStrategy = writestrategies.NewConstantWriteStrategy(&mockGenerator{}, &writer, 1000) }) It("writes messages at a constant rate", func() { go writeStrategy.StartWriter(stopChan) time.Sleep(time.Millisecond * 50) writes := atomic.LoadUint32(&writer.count) Expect(writes).To(BeNumerically(">", 40)) Expect(writes).To(BeNumerically("<", 60)) time.Sleep(time.Millisecond * 50) writes = atomic.LoadUint32(&writer.count) Expect(writes).To(BeNumerically(">", 90)) Expect(writes).To(BeNumerically("<", 110))
type Stopper interface { Stop() } var _ = Describe("End to end benchmarks", func() { benchmarkEndToEnd := func() { Measure("dropsonde metrics being passed from metron to the firehose nozzle", func(b Benchmarker) { const writeRatePerSecond = 1000 metronStreamWriter := endtoend.NewMetronStreamWriter() firehoseReader := endtoend.NewFirehoseReader() generator := messagegenerator.NewValueMetricGenerator() writeStrategy := writestrategies.NewConstantWriteStrategy(generator, metronStreamWriter, writeRatePerSecond) ex := experiment.NewExperiment(firehoseReader) ex.AddWriteStrategy(writeStrategy) ex.Warmup() go stopExperimentAfterTimeout(ex) b.Time("runtime", func() { ex.Start() }) reportResults(firehoseReader, metronStreamWriter.Writes, b) Expect(float64(firehoseReader.MetronSentMessageCount)).To(BeNumerically(">", writeRatePerSecond)) }, 1) Measure("dropsonde metrics being passed from metron to the firehose nozzle in burst sequence", func(b Benchmarker) {
) type Stopper interface { Stop() } var _ = Describe("End to end test", func() { Measure("dropsonde metrics being passed from metron to the firehose nozzle", func(b Benchmarker) { const numMessagesSent = 1000 metronStreamWriter := endtoend.NewMetronStreamWriter() firehoseReader := endtoend.NewFirehoseReader() generator := messagegenerator.NewValueMetricGenerator() writeStrategy := writestrategies.NewConstantWriteStrategy(generator, metronStreamWriter, numMessagesSent) ex := experiment.NewExperiment(firehoseReader) ex.AddWriteStrategy(writeStrategy) go stopExperimentAfterTimeout(ex) b.Time("runtime", func() { ex.Start() }) reportResults(firehoseReader, b) Expect(float64(firehoseReader.MetronMessageCount)).To(BeNumerically(">", numMessagesSent)) }, 3) Measure("dropsonde metrics being passed from metron to the firehose nozzle in burst sequence", func(b Benchmarker) { metronStreamWriter := endtoend.NewMetronStreamWriter()