Revert "chore: firelog exporter (#8555)" (#8598)

This reverts commit 70ed898.

Author: ericzzzzzzz

pkg/skaffold/instrumentation/ci.go

@@ -94,11 +94,6 @@ func exportMetrics(ctx context.Context, filename string, meter skaffoldMeter) er
 	}
 	var meters []skaffoldMeter
 	err = json.Unmarshal(b, &meters)
-	// each meter contains around 20 datapoints, and each datapoint requires a request to firelog api
-	// we send at most 10 meters stored in skaffold metrics as too many request may result in the firelog server returning 429.
-	if len(meters) >= 10 {
-		meters = meters[:10]
-	}
 	if err != nil {
 		meters = []skaffoldMeter{}
 	}
@@ -165,13 +160,17 @@ func devStdOutExporter() (sdkmetric.Exporter, error) {
 }
 
 func createMetrics(ctx context.Context, meter skaffoldMeter) {
-	m := global.Meter("skaffold")
-
+	// There is a minimum 10 second interval that metrics are allowed to upload to Cloud monitoring
 	// A metric is uniquely identified by the metric name and the labels and corresponding values
 	// This random number is used as a label to differentiate the metrics per user so if two users
 	// run `skaffold build` at the same time they will both have their metrics recorded
 	randLabel := attribute.String("randomizer", strconv.Itoa(rand.Intn(75000)))
 
+	m := global.Meter("skaffold")
+
+	// cloud monitoring only supports string type labels
+	// cloud monitoring only supports 10 labels per metric descriptor
+	// be careful when appending new values to this `labels` slice
 	labels := []attribute.KeyValue{
 		attribute.String("version", meter.Version),
 		attribute.String("os", meter.OS),
@@ -181,13 +180,15 @@ func createMetrics(ctx context.Context, meter skaffoldMeter) {
 		attribute.String("platform_type", meter.PlatformType),
 		attribute.String("config_count", strconv.Itoa(meter.ConfigCount)),
 		attribute.String("cluster_type", meter.ClusterType),
-		attribute.String("ci_cd_platform", meter.CISystem),
+	}
+	sharedLabels := []attribute.KeyValue{
 		randLabel,
 	}
 
 	if allowedUser := user.IsAllowedUser(meter.User); allowedUser {
-		labels = append(labels, attribute.String("user", meter.User))
+		sharedLabels = append(sharedLabels, attribute.String("user", meter.User))
 	}
+	labels = append(labels, sharedLabels...)
 	platformLabel := attribute.String("host_os_arch", fmt.Sprintf("%s/%s", meter.OS, meter.Arch))
 	runCounter := NewInt64ValueRecorder(m, "launches", instrument.WithDescription("Skaffold Invocations"))
 	runCounter.Record(ctx, 1, labels...)
@@ -196,36 +197,36 @@ func createMetrics(ctx context.Context, meter skaffoldMeter) {
 		instrument.WithDescription("durations of skaffold commands in seconds"))
 	durationRecorder.Record(ctx, meter.Duration.Seconds(), labels...)
 	if meter.Command != "" {
-		commandMetrics(ctx, meter, m, labels...)
-		flagMetrics(ctx, meter, m, labels...)
+		commandMetrics(ctx, meter, m, sharedLabels...)
+		flagMetrics(ctx, meter, m, randLabel)
 		hooksMetrics(ctx, meter, m, labels...)
 		if doesBuild.Contains(meter.Command) {
-			builderMetrics(ctx, meter, m, platformLabel, labels...)
+			builderMetrics(ctx, meter, m, platformLabel, sharedLabels...)
 		}
 		if doesDeploy.Contains(meter.Command) {
-			deployerMetrics(ctx, meter, m, labels...)
+			deployerMetrics(ctx, meter, m, sharedLabels...)
 		}
 		if doesDeploy.Contains(meter.Command) || meter.Command == "render" {
-			resourceSelectorMetrics(ctx, meter, m, labels...)
+			resourceSelectorMetrics(ctx, meter, m, sharedLabels...)
 		}
 	}
 
 	if meter.ErrorCode != 0 {
-		errorMetrics(ctx, meter, m, append(labels, platformLabel)...)
+		errorMetrics(ctx, meter, m, append(sharedLabels, platformLabel)...)
 	}
 }
 
-func flagMetrics(ctx context.Context, meter skaffoldMeter, m metric.Meter, labels ...attribute.KeyValue) {
+func flagMetrics(ctx context.Context, meter skaffoldMeter, m metric.Meter, randLabel attribute.KeyValue) {
 	flagCounter := NewInt64ValueRecorder(m, "flags", instrument.WithDescription("Tracks usage of enum flags"))
 	for k, v := range meter.EnumFlags {
-		l := []attribute.KeyValue{
+		labels := []attribute.KeyValue{
 			attribute.String("flag_name", k),
 			attribute.String("flag_value", v),
 			attribute.String("command", meter.Command),
 			attribute.String("error", meter.ErrorCode.String()),
+			randLabel,
 		}
-		l = append(l, labels...)
-		flagCounter.Record(ctx, 1, l...)
+		flagCounter.Record(ctx, 1, labels...)
 	}
 }
 
@@ -248,13 +249,12 @@ func commandMetrics(ctx context.Context, meter skaffoldMeter, m metric.Meter, la
 			m := counts[iteration.Intent]
 			m[iteration.ErrorCode]++
 		}
-		randomizer := attribute.String("randomizer2", strconv.Itoa(rand.Intn(75000)))
 		for intention, errorCounts := range counts {
 			for errorCode, count := range errorCounts {
 				iterationCounter.Record(ctx, int64(count),
 					append(labels,
 						attribute.String("intent", intention),
-						attribute.String("error", errorCode.String()), randomizer,
+						attribute.String("error", errorCode.String()),
 					)...)
 			}
 		}

pkg/skaffold/instrumentation/export.go

@@ -31,7 +31,6 @@ import (
 	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
 
 	"github.com/GoogleContainerTools/skaffold/v2/fs"
-	"github.com/GoogleContainerTools/skaffold/v2/pkg/skaffold/instrumentation/firelog"
 	"github.com/GoogleContainerTools/skaffold/v2/proto/v1"
 	"github.com/GoogleContainerTools/skaffold/v2/testutil"
 )
@@ -106,7 +105,7 @@ func TestExportMetrics(t *testing.T) {
 		StartTime:                    startTime.Add(time.Hour * 24 * 10),
 		Duration:                     time.Minute * 4,
 	}
-	metersBytes, _ := json.Marshal([]skaffoldMeter{devMeter, debugMeter, buildMeter})
+	metersBytes, _ := json.Marshal([]skaffoldMeter{buildMeter, devMeter, debugMeter})
 	fakeFS := testutil.FakeFileSystem{
 		Files: map[string][]byte{
 			"assets/secrets_generated/keys.json": []byte(testKey),
@@ -169,7 +168,6 @@ func TestExportMetrics(t *testing.T) {
 
 			fs.AssetsFS = fakeFS
 			t.Override(&isOnline, test.isOnline)
-			t.Override(&firelog.APIKey, "no-empty")
 
 			if test.isOnline {
 				tmpFile, err := os.OpenFile(tmp.Path(openTelFilename), os.O_RDWR|os.O_CREATE, os.ModePerm)
@@ -408,7 +406,6 @@ func checkOutput(t *testutil.T, meters []skaffoldMeter, b []byte) {
 	platform := make(map[interface{}]int)
 	buildPlatforms := make(map[interface{}]int)
 	cliPlatforms := make(map[interface{}]int)
-	ciCDPlatforms := make(map[interface{}]int)
 	nodePlatforms := make(map[interface{}]int)
 
 	testMaps := []map[interface{}]int{
@@ -422,7 +419,6 @@ func checkOutput(t *testutil.T, meters []skaffoldMeter, b []byte) {
 		commandCount[meter.Command]++
 		errorCount[meter.ErrorCode.String()]++
 		platform[meter.PlatformType]++
-		ciCDPlatforms[meter.CISystem]++
 
 		for k, v := range meter.EnumFlags {
 			n := strings.ReplaceAll(k, "-", "_")
@@ -489,6 +485,10 @@ func checkOutput(t *testutil.T, meters []skaffoldMeter, b []byte) {
 			}
 		}
 	}
+	for _, l := range lines {
+		fmt.Println(l.Name)
+		fmt.Println(l.Labels)
+	}
 
 	for _, l := range lines {
 		switch l.Name {
@@ -578,10 +578,6 @@ func checkOutput(t *testutil.T, meters []skaffoldMeter, b []byte) {
 			if v, ok := l.Labels["cli-platforms"]; ok {
 				cliPlatforms[v]++
 			}
-		case "ci-cd-platforms":
-			if v, ok := l.Labels["ci-cd-platforms"]; ok {
-				ciCDPlatforms[v]++
-			}
 		default:
 			switch {
 			case MeteredCommands.Contains(l.Name):