func main()

in spanner_prober/main.go [47:148]
86 lines of code
13 McCabe index (conditional complexity)

func main() {
	flag.Parse()
	ctx := context.Background()

	errs := validateFlags()
	if len(errs) > 0 {
		log.Errorf("Flag validation failed with %v errors", len(errs))
		for _, err := range errs {
			log.Errorf("%v", err)
		}
		log.Exit("Flag validation failed... exiting.")
	}

	fmt.Printf("Prober started with options:\nenable_cloud_ops: %v\nproject: %q\n"+
		"ops_project: %q\ninstance: %q\ndatabase: %q\ninstance_config: %q\n"+
		"node_count: %d\nprocessing_units: %d\nqps: %0.3f\nnum_rows: %d\n"+
		"probe_type: %q\nmax_staleness: %v\npayload_size: %d\nprobe_deadline: %v\n"+
		"grpc_gcp: %v\nchannels: %v\nendpoint: %q\n", *enableCloudOps, *project, *opsProject, *instance_name,
		*database_name, *instanceConfig, *nodeCount, *processingUnits, *qps, *numRows,
		*probeType, *maxStaleness, *payloadSize, *probeDeadline, *useGrpcGcp, *channelPoolSize,
		*endpoint)

	grpclog.SetLoggerV2(grpclog.NewLoggerV2(ioutil.Discard, /* Discard logs at INFO level */
		os.Stderr, os.Stderr))

	if *enableCloudOps {
		// Set up the stackdriver exporter for sending metrics.

		// Register gRPC views.
		if err := view.Register(ocgrpc.DefaultClientViews...); err != nil {
			log.Fatalf("Failed to register ocgrpc client views: %v", err)
		}

		// Enable all default views for Cloud Spanner.
		if err := spanner.EnableStatViews(); err != nil {
			log.Errorf("Failed to export stats view: %v", err)
		}

		getPrefix := func(name string) string {
			if strings.HasPrefix(name, proberlib.MetricPrefix) {
				return ""
			}
			return proberlib.MetricPrefix
		}
		exporterOptions := stackdriver.Options{
			ProjectID:            *project,
			BundleDelayThreshold: 60 * time.Second,
			BundleCountThreshold: 3000,
			GetMetricPrefix:      getPrefix,
		}
		if *opsProject != "" {
			exporterOptions.ProjectID = *opsProject
		}
		if os.Getenv(resource.EnvVarType) == "" {
			exporterOptions.MonitoredResource = &MonitoredResource{delegate: monitoredresource.Autodetect()}
		}
		sd, err := stackdriver.NewExporter(exporterOptions)

		if err != nil {
			log.Fatalf("Failed to create the StackDriver exporter: %v", err)
		}
		defer sd.Flush()
		sd.StartMetricsExporter()
		defer sd.StopMetricsExporter()
	}

	prober, err := proberlib.ParseProbeType(*probeType)
	if err != nil {
		log.Exitf("Could not create prober due to %v.", err)
	}

	opts := proberlib.ProberOptions{
		Project:         *project,
		Instance:        *instance_name,
		Database:        *database_name,
		InstanceConfig:  *instanceConfig,
		QPS:             *qps,
		NumRows:         *numRows,
		Prober:          prober,
		MaxStaleness:    *maxStaleness,
		PayloadSize:     *payloadSize,
		ProbeDeadline:   *probeDeadline,
		Endpoint:        *endpoint,
		NodeCount:       *nodeCount,
		ProcessingUnits: *processingUnits,
		UseGrpcGcp:      *useGrpcGcp,
		ChannelPoolSize: *channelPoolSize,
	}

	p, err := proberlib.NewProber(ctx, opts)
	if err != nil {
		log.Exitf("Failed to initialize the cloud prober, %v", err)
	}
	p.Start(ctx)

	cancelChan := make(chan os.Signal, 1)
	signal.Notify(cancelChan, syscall.SIGTERM, syscall.SIGINT)

	select {
	case <-cancelChan:
	}
}