DoltLab `send_doltlab_deployed_event`

main.go

package main

import (
	"context"
	"crypto/tls"
	"flag"
	"fmt"
	"github.com/denisbrodbeck/machineid"
	eventsapi "github.com/dolthub/dolt/go/gen/proto/dolt/services/eventsapi/v1alpha1"
	"github.com/dolthub/dolt/go/libraries/doltcore/env"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/protobuf/types/known/timestamppb"
	"log"
	"os"
	"runtime"
	"strings"
	"unicode"
)

const (
	dev  = "eventsapi.awsdev.ld-corp.com"
	prod = env.DefaultMetricsHost
)

var version = flag.String("version", "doltlab_version_unspecified", "the doltlab version being deployed")

func main() {
	flag.Parse()
	if *version == "" {
		log.Fatal("Must specify --version")
	}

	metricsHost := prod
	if os.Getenv("METRICS_HOST") == "dev" {
		fmt.Println("Emitting metrics to dev events server")
		metricsHost = dev
	}

	client := externalClientEventsAPIDialConfig(eventsapi.AppID_APP_DOLT_LAB, metricsHost, *version)
	if client != nil {
		emitter := newGrpcEmitter(client, eventsapi.AppID_APP_DOLT_LAB, *version)
		machineID, err := machineid.ProtectedID("doltlab")
		if err == nil {
			doltLabWasDeployedEvent := &eventsapi.ClientEvent{
				Id:        machineID,
				StartTime: timestamppb.Now(),
				EndTime:   timestamppb.Now(),
				Type:      eventsapi.ClientEventType_DOLTLAB_INSTANCE_DEPLOYED,
			}
			err = emitter.LogEvents(context.Background(), machineID, []*eventsapi.ClientEvent{doltLabWasDeployedEvent})
			if err == nil {
				fmt.Println("Successfully sent usage metrics!")
			}
		}
	}
}

type grpcEmitter struct {
	client  eventsapi.ClientEventsServiceClient
	appID   eventsapi.AppID
	version string
}

func newGrpcEmitter(logEventsClient eventsapi.ClientEventsServiceClient, id eventsapi.AppID, version string) *grpcEmitter {
	if logEventsClient != nil {
		return &grpcEmitter{
			client:  logEventsClient,
			appID:   id,
			version: version,
		}
	}
	return &grpcEmitter{}
}

func (em *grpcEmitter) LogEvents(ctx context.Context, machineID string, evts []*eventsapi.ClientEvent) error {
	if len(evts) > 0 {
		req := eventsapi.LogEventsRequest{
			MachineId: machineID,
			Version:   em.version,
			Platform:  eventsapi.Platform_SERVICES,
			App:       em.appID,
			Events:    evts,
		}
		if em.client != nil {
			em.client.LogEvents(ctx, &req)
		}
	}
	return nil
}

func externalClientEventsAPIDialConfig(app eventsapi.AppID, metricsHost, version string) eventsapi.ClientEventsServiceClient {
	endpoint := fmt.Sprintf("%s:443", metricsHost)
	tc := credentials.NewTLS(&tls.Config{})
	opts := []grpc.DialOption{
		grpc.WithTransportCredentials(tc),
		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(128 * 1024 * 1024)),
		grpc.WithUserAgent(getUserAgentString(app, version)),
	}
	conn, err := grpc.Dial(endpoint, opts...)
	if err == nil {
		return eventsapi.NewClientEventsServiceClient(conn)
	}
	return nil
}

func getUserAgentString(app eventsapi.AppID, version string) string {
	tokens := []string{
		string(app),
		version,
		runtime.GOOS,
		runtime.GOARCH,
	}
	for i, t := range tokens {
		tokens[i] = strings.Map(func(r rune) rune {
			if unicode.IsSpace(r) {
				return '_'
			}
			return r
		}, strings.TrimSpace(t))
	}
	return strings.Join(tokens, " ")
}