PO to GMP Migration Tool: Orchestrator & CLI Boilerplate

cmd/gmp-migrate/Dockerfile

@@ -0,0 +1,55 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FROM --platform=$BUILDPLATFORM google-go.pkg.dev/golang:1.26.4@sha256:3444149d0a7e3f7cfb9c2db65f0f75676fe6ad04de3ce72674efb120c08dd1c1 AS buildbase
+ARG TARGETOS
+ARG TARGETARCH
+ARG BUILDARCH
+WORKDIR /app
+COPY charts/values.global.yaml charts/values.global.yaml
+COPY go.mod go.mod
+COPY go.sum go.sum
+COPY tools tools
+# Copy the Go vendor directory only if it exists. Vendor folder will automatically
+# cause 'go build' to use -mod=vendor flag (otherwise -mod=mod is used).
+COPY vendor* vendor
+COPY cmd cmd
+COPY pkg pkg
+
+ENV GOEXPERIMENT=boringcrypto
+ENV CGO_ENABLED=1
+ENV GOFIPS140=off
+ENV GOTOOLCHAIN=local
+ENV GOOS=${TARGETOS}
+ENV GOARCH=${TARGETARCH}
+RUN if [ "${TARGETARCH}" = "arm64" ] && [ "${BUILDARCH}" != "arm64" ]; then \
+	apt-get update && apt-get install -y --no-install-recommends \
+	gcc-aarch64-linux-gnu libc6-dev-arm64-cross; \
+	export CC=aarch64-linux-gnu-gcc; \
+	elif [ "${TARGETARCH}" = "amd64" ] && [ "${BUILDARCH}" != "amd64" ]; then \
+	apt-get update && apt-get install -y --no-install-recommends \
+	gcc-x86-64-linux-gnu libc6-dev-amd64-cross; \
+	export CC=x86_64-linux-gnu-gcc; \
+	fi && \
+	GOOS=${TARGETOS} GOARCH=${TARGETARCH} \
+	go build \
+	-ldflags="-X github.com/prometheus/common/version.Version=$(cat charts/values.global.yaml | go tool -modfile="tools/go.mod" yq '.version' ) \
+	-X github.com/prometheus/common/version.BuildDate=$(date --iso-8601=seconds)" \
+	-o gmp-migrate \
+	cmd/gmp-migrate/*.go
+
+
+FROM gke.gcr.io/gke-distroless/libc:gke_distroless_20260307.00_p0@sha256:d5c073079125b887158bb1dd0ee4da49b39a08203c3c96124ee310962dd5aae2
+COPY --from=buildbase /app/gmp-migrate /bin/gmp-migrate
+ENTRYPOINT ["/bin/gmp-migrate"]

cmd/gmp-migrate/main.go

@@ -0,0 +1,58 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log/slog"
+	"os"
+
+	"github.com/GoogleCloudPlatform/prometheus-engine/pkg/migrate"
+)
+
+func main() {
+	slog.SetDefault(slog.New(migrate.NewConsoleHandler(os.Stderr)))
+
+	var inputFile string
+	flag.StringVar(&inputFile, "file", "", "Input source (YAML file, directory, or '-' for stdin) (Required)")
+	flag.StringVar(&inputFile, "f", "", "Input source (YAML file, directory, or '-' for stdin) (Required)")
+
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
+		fmt.Fprint(os.Stderr, "Migrate Prometheus Operator configurations to Google Managed Prometheus (GMP).\n\n")
+		flag.PrintDefaults()
+	}
+	flag.Parse()
+
+	if inputFile == "" {
+		slog.Error("Flag -f / --file is required.")
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	migrator := migrate.NewMigrator()
+	report, err := migrator.Run(inputFile)
+	if err != nil {
+		slog.Error("Migration failed", slog.Any("error", err))
+		os.Exit(1)
+	}
+
+	// If any resource failed to migrate, exit with a non-zero code.
+	if report.FailedCount > 0 {
+		slog.Error("Migration completed with failures", slog.Int("failures", report.FailedCount))
+		os.Exit(1)
+	}
+}

go.mod

@@ -44,7 +44,10 @@ require (
 	sigs.k8s.io/controller-runtime v0.18.7
 )
 
-require github.com/efficientgo/e2e v0.14.1-0.20230710114240-c316eb95ae5b
+require (
+	github.com/efficientgo/e2e v0.14.1-0.20230710114240-c316eb95ae5b
+	sigs.k8s.io/yaml v1.6.0
+)
 
 require (
 	cloud.google.com/go/auth v0.16.5 // indirect
@@ -83,7 +86,7 @@ require (
 	github.com/edsrzf/mmap-go v1.2.0 // indirect
 	github.com/efficientgo/core v1.0.0-rc.3 // indirect
 	github.com/emicklei/go-restful/v3 v3.13.0 // indirect
-	github.com/evanphx/json-patch v5.6.0+incompatible // indirect
+	github.com/evanphx/json-patch v5.9.0+incompatible // indirect
 	github.com/evanphx/json-patch/v5 v5.9.11 // indirect
 	github.com/facette/natsort v0.0.0-20181210072756-2cd4dd1e2dcb // indirect
 	github.com/fatih/color v1.18.0 // indirect
@@ -114,7 +117,7 @@ require (
 	github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674 // indirect
 	github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc // indirect
 	github.com/hashicorp/go-version v1.7.0 // indirect
-	github.com/imdario/mergo v0.3.6 // indirect
+	github.com/imdario/mergo v0.3.16 // indirect
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/jpillora/backoff v1.0.0 // indirect
@@ -176,7 +179,6 @@ require (
 	sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730 // indirect
 	sigs.k8s.io/randfill v1.0.0 // indirect
 	sigs.k8s.io/structured-merge-diff/v4 v4.7.0 // indirect
-	sigs.k8s.io/yaml v1.6.0 // indirect
 )
 
 replace (

pkg/migrate/logger.go

@@ -0,0 +1,212 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package migrate
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log/slog"
+	"maps"
+	"os"
+	"strings"
+	"sync"
+)
+
+// Custom slog.Levels for status logging.
+const (
+	LevelSuccess slog.Level = slog.LevelInfo - 1 // Level -1 (Standard Info is 0)
+	LevelSkipped slog.Level = slog.LevelInfo + 1 // Level 1
+)
+
+// ResourceStatus defines the final migration state of an ingested resource.
+type ResourceStatus int
+
+const (
+	StatusSuccess ResourceStatus = iota // 0 (Migrated Successfully)
+	StatusSkipped                       // 1 (Skipped / Unsupported)
+	StatusWarning                       // 2 (Migrated with Warnings)
+	StatusFailed                        // 3 (Failed)
+)
+
+// statusLevels maps slog.Levels to their corresponding ResourceStatus.
+// Levels omitted from this map (like slog.LevelInfo) represent progress logs
+// and are ignored for status tracking.
+var statusLevels = map[slog.Level]ResourceStatus{
+	LevelSuccess:    StatusSuccess,
+	LevelSkipped:    StatusSkipped,
+	slog.LevelWarn:  StatusWarning,
+	slog.LevelError: StatusFailed,
+}
+
+// loggerState encapsulates the shared, thread-safe state across all handler clones.
+type loggerState struct {
+	mu               sync.Mutex
+	resourceStatuses map[string]ResourceStatus
+}
+
+// ConsoleHandler is a thread-safe slog.Handler that formats logs for the console (Stderr)
+// and tracks the highest log level seen per resource (for statistics).
+type ConsoleHandler struct {
+	out   io.Writer
+	state *loggerState
+	attrs []slog.Attr
+}
+
+// NewConsoleHandler creates a new ConsoleHandler.
+func NewConsoleHandler(out io.Writer) *ConsoleHandler {
+	if out == nil {
+		out = os.Stderr
+	}
+	return &ConsoleHandler{
+		out: out,
+		state: &loggerState{
+			resourceStatuses: make(map[string]ResourceStatus),
+		},
+	}
+}
+
+func (h *ConsoleHandler) Enabled(_ context.Context, _ slog.Level) bool {
+	return true // Log everything
+}
+
+func (h *ConsoleHandler) Handle(_ context.Context, r slog.Record) error {
+	h.state.mu.Lock()
+	defer h.state.mu.Unlock()
+
+	var kind, namespace, name, file string
+	var extraAttrs []string
+
+	// Helper to process and categorize attributes
+	processAttr := func(a slog.Attr) {
+		val := a.Value.Resolve()
+		switch a.Key {
+		case "kind":
+			kind = val.String()
+		case "namespace":
+			namespace = val.String()
+		case "name":
+			name = val.String()
+		case "file":
+			file = val.String()
+		default:
+			// Collect all other attributes to print at the end of the line
+			extraAttrs = append(extraAttrs, fmt.Sprintf("%s=%v", a.Key, val.Any()))
+		}
+	}
+
+	// Extract attributes bound to the logger instance
+	for _, a := range h.attrs {
+		processAttr(a)
+	}
+
+	// Extract attributes passed in the individual log call
+	r.Attrs(func(a slog.Attr) bool {
+		processAttr(a)
+		return true
+	})
+
+	// Map slog.Level to string for console output.
+	var levelStr string
+	switch r.Level {
+	case slog.LevelDebug:
+		levelStr = "DEBUG"
+	case slog.LevelInfo:
+		levelStr = "INFO"
+	case LevelSuccess:
+		levelStr = "SUCCESS"
+	case LevelSkipped:
+		levelStr = "SKIPPED"
+	case slog.LevelWarn:
+		levelStr = "WARNING"
+	case slog.LevelError:
+		levelStr = "ERROR"
+	default:
+		levelStr = r.Level.String()
+	}
+
+	// Format prefix cleanly
+	var prefix string
+	if file != "" {
+		prefix = fmt.Sprintf("[%s] ", file)
+	} else if kind != "" && name != "" {
+		if namespace == "" {
+			prefix = fmt.Sprintf("[%s:%s] ", kind, name)
+		} else {
+			prefix = fmt.Sprintf("[%s:%s/%s] ", kind, namespace, name)
+		}
+	}
+
+	// 1. Write formatted log to Stderr (console), appending extra attributes if any.
+	var suffix string
+	if len(extraAttrs) > 0 {
+		suffix = " " + strings.Join(extraAttrs, " ")
+	}
+	consoleLine := fmt.Sprintf("[%s] %s%s%s\n", levelStr, prefix, r.Message, suffix)
+	if _, err := io.WriteString(h.out, consoleLine); err != nil {
+		return err
+	}
+
+	// 2. Track the migration status of the resource (for final report)
+	// Only update the map if the log level represents an actual status milestone.
+	if status, ok := statusLevels[r.Level]; ok {
+		if kind != "" && name != "" {
+			var key string
+			if namespace == "" {
+				key = fmt.Sprintf("%s/%s", kind, name)
+			} else {
+				key = fmt.Sprintf("%s/%s/%s", kind, namespace, name)
+			}
+			if val, exists := h.state.resourceStatuses[key]; !exists || status > val {
+				h.state.resourceStatuses[key] = status
+			}
+		} else if file != "" {
+			// Track file-level log status under the file path key
+			if val, exists := h.state.resourceStatuses[file]; !exists || status > val {
+				h.state.resourceStatuses[file] = status
+			}
+		}
+	}
+
+	return nil
+}
+
+func (h *ConsoleHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	// 1. Allocate a brand-new, independent underlying array of exact size
+	newAttrs := make([]slog.Attr, len(h.attrs)+len(attrs))
+
+	// 2. Copy the parent's attributes to the beginning of the new array
+	copy(newAttrs, h.attrs)
+
+	// 3. Copy the new attributes to the remaining space, starting at the offset
+	copy(newAttrs[len(h.attrs):], attrs)
+	return &ConsoleHandler{
+		out:   h.out,
+		state: h.state,
+		attrs: newAttrs,
+	}
+}
+
+func (h *ConsoleHandler) WithGroup(_ string) slog.Handler {
+	return h
+}
+
+// ResourceStatuses returns a thread-safe copy of the tracked resource statuses.
+func (h *ConsoleHandler) ResourceStatuses() map[string]ResourceStatus {
+	h.state.mu.Lock()
+	defer h.state.mu.Unlock()
+
+	return maps.Clone(h.state.resourceStatuses)
+}