func main()

in tools/cmd/log-load/main.go [28:116]
71 lines of code
9 McCabe index (conditional complexity)

func main() {
	var (
		target                          string
		verbose, dryRun                 bool
		concurrency                     int
		batchSize, metrics, cardinality int
		totalSamples                    int64
	)

	flag.BoolVar(&verbose, "verbose", false, "Verbose logging")
	flag.StringVar(&target, "target", "", "Remote write URL")
	flag.IntVar(&concurrency, "concurrency", 1, "Concurrent writers")

	flag.IntVar(&batchSize, "batch-size", 2500, "Batch size of requests")
	flag.BoolVar(&dryRun, "dry-run", false, "Read data but don't send it")
	flag.Int64Var(&totalSamples, "total-samples", 0, "Total samples to send (0 = continuous)")

	flag.Parse()

	target = fmt.Sprintf("%s/v1/logs", target)

	var dataGen generator

	generator := &continuousDataGenerator{
		set: data.NewDataSet(data.SetOptions{
			NumMetrics:  metrics,
			Cardinality: cardinality,
		}),
		startTime:    time.Now().UTC(),
		batchSize:    batchSize,
		totalSamples: totalSamples,
	}
	dataGen = generator

	batches := make(chan *v1.ExportLogsServiceRequest, 1000)

	stats := newStats()

	var wg sync.WaitGroup
	ctx, cancel := context.WithCancel(context.Background())
	for i := 0; i < concurrency; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			writer(ctx, target, stats, batches)
		}()
	}

	go reportStats(ctx, stats, batches)

	stats.StartTimer()

	for {

		var err error
		batch, err := dataGen.Read()
		if err == io.EOF {
			break
		} else if err != nil {
			fmt.Println(err.Error())
			return
		}

		if !dryRun {
			batches <- batch
		} else {
			for _, ts := range batch.ResourceLogs {
				for _, scope := range ts.ScopeLogs {
					stats.IncTotalSent(len(scope.LogRecords))
				}
			}
		}
	}

	for len(batches) > 0 {
		println(len(batches))
		time.Sleep(100 * time.Millisecond)

	}

	stats.StopTimer()
	cancel()
	wg.Wait()

	fmt.Printf("Total Metrics: %d\n", stats.TotalMetrics())
	fmt.Printf("Total Samples: %d\n", stats.TotalSeries())
	fmt.Printf("Duration: %s\n", stats.TimerDuration().String())
	fmt.Printf("Load samples per/sec: %0.2f\n", float64(stats.TotalSeries())/stats.TimerDuration().Seconds())
}