# Copyright The Prometheus Authors

# 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.

# A common Makefile that includes rules to be reused in different prometheus projects.

# !!! Open PRs only against the prometheus/prometheus/Makefile.common repository!

# Example usage :

# Create the main Makefile in the root project directory.

# include Makefile.common

# customTarget:

# @echo ">> Running customTarget"

#

# Ensure GOBIN is not set during build so that promu is installed to the correct path

unexport GOBIN

GO ?= go

GOFMT ?= $(GO)fmt

FIRST_GOPATH := $(firstword $(subst :, ,$(shell $(GO) env GOPATH)))

GOOPTS ?=

GOHOSTOS ?= $(shell $(GO) env GOHOSTOS)

GOHOSTARCH ?= $(shell $(GO) env GOHOSTARCH)

GO_VERSION ?= $(shell $(GO) version)

GO_VERSION_NUMBER ?= $(word 3, $(GO_VERSION))

PRE_GO_111 ?= $(shell echo $(GO_VERSION_NUMBER) | grep -E 'go1\.(10|[0-9])\.')

PROMU := $(FIRST_GOPATH)/bin/promu

pkgs = ./...

ifeq (arm, $(GOHOSTARCH))

GOHOSTARM ?= $(shell GOARM= $(GO) env GOARM)

GO_BUILD_PLATFORM ?= $(GOHOSTOS)-$(GOHOSTARCH)v$(GOHOSTARM)

else

GO_BUILD_PLATFORM ?= $(GOHOSTOS)-$(GOHOSTARCH)

endif

GOTEST := $(GO) test

GOTEST_DIR :=

ifneq ($(CIRCLE_JOB),)

ifneq ($(shell command -v gotestsum 2> /dev/null),)

GOTEST_DIR := test-results

GOTEST := gotestsum --junitfile $(GOTEST_DIR)/unit-tests.xml --

endif

endif

PROMU_VERSION ?= 0.20.0

PROMU_URL := https://github.com/prometheus/promu/releases/download/v$(PROMU_VERSION)/promu-$(PROMU_VERSION).$(GO_BUILD_PLATFORM).tar.gz

SKIP_GOLANGCI_LINT :=

GOLANGCI_LINT :=

GOLANGCI_LINT_OPTS ?=

GOLANGCI_LINT_VERSION ?= v2.11.4

GOLANGCI_FMT_OPTS ?=

# golangci-lint only supports linux, darwin and windows platforms on i386/amd64/arm64.

# windows isn't included here because of the path separator being different.

ifeq ($(GOHOSTOS),$(filter $(GOHOSTOS),linux darwin))

ifeq ($(GOHOSTARCH),$(filter $(GOHOSTARCH),amd64 i386 arm64))

# If we're in CI and there is an Actions file, that means the linter

# is being run in Actions, so we don't need to run it here.

ifneq (,$(SKIP_GOLANGCI_LINT))

GOLANGCI_LINT :=

else ifeq (,$(CIRCLE_JOB))

GOLANGCI_LINT := $(FIRST_GOPATH)/bin/golangci-lint

else ifeq (,$(wildcard .github/workflows/golangci-lint.yml))

GOLANGCI_LINT := $(FIRST_GOPATH)/bin/golangci-lint

endif

endif

endif

PREFIX ?= $(shell pwd)

BIN_DIR ?= $(shell pwd)

DOCKER_IMAGE_TAG ?= $(subst /,-,$(shell git rev-parse --abbrev-ref HEAD))

DOCKERBUILD_CONTEXT ?= ./

DOCKER_REPO ?= prom

# Check if deprecated DOCKERFILE_PATH is set

ifdef DOCKERFILE_PATH

$(error DOCKERFILE_PATH is deprecated. Use DOCKERFILE_VARIANTS ?= $(DOCKERFILE_PATH) in the Makefile)

endif

DOCKER_ARCHS ?= amd64 arm64 armv7 ppc64le riscv64 s390x

DOCKERFILE_VARIANTS ?= $(wildcard Dockerfile Dockerfile.*)

# Function to extract variant from Dockerfile label.

# Returns the variant name from io.prometheus.image.variant label, or "default" if not found.

define dockerfile_variant

$(strip $(or $(shell sed -n 's/.*io\.prometheus\.image\.variant="\([^"]*\)".*/\1/p' $(1)),default))

endef

# Check for duplicate variant names (including default for Dockerfiles without labels).

DOCKERFILE_VARIANT_NAMES := $(foreach df,$(DOCKERFILE_VARIANTS),$(call dockerfile_variant,$(df)))

DOCKERFILE_VARIANT_NAMES_SORTED := $(sort $(DOCKERFILE_VARIANT_NAMES))

ifneq ($(words $(DOCKERFILE_VARIANT_NAMES)),$(words $(DOCKERFILE_VARIANT_NAMES_SORTED)))

$(error Duplicate variant names found. Each Dockerfile must have a unique io.prometheus.image.variant label, and only one can be without a label (default))

endif

# Build variant:dockerfile pairs for shell iteration.

DOCKERFILE_VARIANTS_WITH_NAMES := $(foreach df,$(DOCKERFILE_VARIANTS),$(call dockerfile_variant,$(df)):$(df))

BUILD_DOCKER_ARCHS = $(addprefix common-docker-,$(DOCKER_ARCHS))

PUBLISH_DOCKER_ARCHS = $(addprefix common-docker-publish-,$(DOCKER_ARCHS))

TAG_DOCKER_ARCHS = $(addprefix common-docker-tag-latest-,$(DOCKER_ARCHS))

SANITIZED_DOCKER_IMAGE_TAG := $(subst +,-,$(DOCKER_IMAGE_TAG))

ifeq ($(GOHOSTARCH),amd64)

ifeq ($(GOHOSTOS),$(filter $(GOHOSTOS),linux freebsd darwin windows))

# Only supported on amd64

test-flags := -race

endif

endif

# This rule is used to forward a target like "build" to "common-build". This

# allows a new "build" target to be defined in a Makefile which includes this

# one and override "common-build" without override warnings.

%: common-% ;

.PHONY: common-all

common-all: precheck style check_license lint yamllint unused build test

.PHONY: common-style

common-style:

@echo ">> checking code style"

@fmtRes=$$($(GOFMT) -d $$(git ls-files '*.go' ':!:vendor/*' || find . -path ./vendor -prune -o -name '*.go' -print)); \

if [ -n "$${fmtRes}" ]; then \

echo "gofmt checking failed!"; echo "$${fmtRes}"; echo; \

echo "Please ensure you are using $$($(GO) version) for formatting code."; \

exit 1; \

fi

.PHONY: common-check_license

common-check_license:

@echo ">> checking license header"

@licRes=$$(for file in $$(git ls-files '*.go' ':!:vendor/*' || find . -path ./vendor -prune -o -type f -iname '*.go' -print) ; do \

awk 'NR<=3' $$file | grep -Eq "(Copyright|generated|GENERATED)" || echo $$file; \

done); \

if [ -n "$${licRes}" ]; then \

echo "license header checking failed:"; echo "$${licRes}"; \

exit 1; \

fi

@echo ">> checking for copyright years 2026 or later"

@futureYearRes=$$(git grep -E 'Copyright (202[6-9]|20[3-9][0-9])' -- '*.go' ':!:vendor/*' || true); \

if [ -n "$${futureYearRes}" ]; then \

echo "Files with copyright year 2026 or later found (should use 'Copyright The Prometheus Authors'):"; echo "$${futureYearRes}"; \

exit 1; \

fi

.PHONY: common-deps

common-deps:

@echo ">> getting dependencies"

$(GO) mod download

.PHONY: update-go-deps

update-go-deps:

@echo ">> updating Go dependencies"

@for m in $$($(GO) list -mod=readonly -m -f '{{ if and (not .Indirect) (not .Main)}}{{.Path}}{{end}}' all); do \

$(GO) get $$m; \

done

$(GO) mod tidy

.PHONY: common-test-short

common-test-short: $(GOTEST_DIR)

@echo ">> running short tests"

$(GOTEST) -short $(GOOPTS) $(pkgs)

.PHONY: common-test

common-test: $(GOTEST_DIR)

@echo ">> running all tests"

$(GOTEST) $(test-flags) $(GOOPTS) $(pkgs)

$(GOTEST_DIR):

@mkdir -p $@

.PHONY: common-format

common-format: $(GOLANGCI_LINT)

@echo ">> formatting code"

$(GO) fmt $(pkgs)

ifdef GOLANGCI_LINT

@echo ">> formatting code with golangci-lint"

$(GOLANGCI_LINT) fmt $(GOLANGCI_FMT_OPTS)

endif

.PHONY: common-vet

common-vet:

@echo ">> vetting code"

$(GO) vet $(GOOPTS) $(pkgs)

.PHONY: common-lint

common-lint: $(GOLANGCI_LINT)

ifdef GOLANGCI_LINT

@echo ">> running golangci-lint"

$(GOLANGCI_LINT) run $(GOLANGCI_LINT_OPTS) $(pkgs)

endif

.PHONY: common-lint-fix

common-lint-fix: $(GOLANGCI_LINT)

ifdef GOLANGCI_LINT

@echo ">> running golangci-lint fix"

$(GOLANGCI_LINT) run --fix $(GOLANGCI_LINT_OPTS) $(pkgs)

endif

.PHONY: common-yamllint

common-yamllint:

@echo ">> running yamllint on all YAML files in the repository"

ifeq (, $(shell command -v yamllint 2> /dev/null))

@echo "yamllint not installed so skipping"

else

yamllint .

endif

# For backward-compatibility.

.PHONY: common-staticcheck

common-staticcheck: lint

.PHONY: common-unused

common-unused:

@echo ">> running check for unused/missing packages in go.mod"

$(GO) mod tidy

@git diff --exit-code -- go.sum go.mod

.PHONY: common-build

common-build: promu

@echo ">> building binaries"

$(PROMU) build --prefix $(PREFIX) $(PROMU_BINARIES)

.PHONY: common-tarball

common-tarball: promu

@echo ">> building release tarball"

$(PROMU) tarball --prefix $(PREFIX) $(BIN_DIR)

.PHONY: common-docker-repo-name

common-docker-repo-name:

@echo "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)"

.PHONY: common-docker $(BUILD_DOCKER_ARCHS)

common-docker: $(BUILD_DOCKER_ARCHS)

$(BUILD_DOCKER_ARCHS): common-docker-%:

@for variant in $(DOCKERFILE_VARIANTS_WITH_NAMES); do \

dockerfile=$${variant#*:}; \

variant_name=$${variant%%:*}; \

distroless_arch="$*"; \

if [ "$*" = "armv7" ]; then \

distroless_arch="arm"; \

fi; \

if [ "$$dockerfile" = "Dockerfile" ]; then \

echo "Building default variant ($$variant_name) for linux-$* using $$dockerfile"; \

docker build -t "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)" \

-f $$dockerfile \

--build-arg ARCH="$*" \

--build-arg OS="linux" \

--build-arg DISTROLESS_ARCH="$$distroless_arch" \

$(DOCKERBUILD_CONTEXT); \

if [ "$$variant_name" != "default" ]; then \

echo "Tagging default variant with $$variant_name suffix"; \

docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)" \

"$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)-$$variant_name"; \

fi; \

else \

echo "Building $$variant_name variant for linux-$* using $$dockerfile"; \

docker build -t "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)-$$variant_name" \

-f $$dockerfile \

--build-arg ARCH="$*" \

--build-arg OS="linux" \

--build-arg DISTROLESS_ARCH="$$distroless_arch" \

$(DOCKERBUILD_CONTEXT); \

fi; \

done

.PHONY: common-docker-publish $(PUBLISH_DOCKER_ARCHS)

common-docker-publish: $(PUBLISH_DOCKER_ARCHS)

$(PUBLISH_DOCKER_ARCHS): common-docker-publish-%:

@for variant in $(DOCKERFILE_VARIANTS_WITH_NAMES); do \

dockerfile=$${variant#*:}; \

variant_name=$${variant%%:*}; \

if [ "$$dockerfile" != "Dockerfile" ] || [ "$$variant_name" != "default" ]; then \

echo "Pushing $$variant_name variant for linux-$*"; \

docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)-$$variant_name"; \

fi; \

if [ "$$dockerfile" = "Dockerfile" ]; then \

echo "Pushing default variant ($$variant_name) for linux-$*"; \

docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)"; \

fi; \

if [ "$(DOCKER_IMAGE_TAG)" = "latest" ]; then \

if [ "$$dockerfile" != "Dockerfile" ] || [ "$$variant_name" != "default" ]; then \

echo "Pushing $$variant_name variant version tags for linux-$*"; \

docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:v$(DOCKER_MAJOR_VERSION_TAG)-$$variant_name"; \

fi; \

if [ "$$dockerfile" = "Dockerfile" ]; then \

echo "Pushing default variant version tag for linux-$*"; \

docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:v$(DOCKER_MAJOR_VERSION_TAG)"; \

fi; \

fi; \

done

DOCKER_MAJOR_VERSION_TAG = $(firstword $(subst ., ,$(shell cat VERSION)))

.PHONY: common-docker-tag-latest $(TAG_DOCKER_ARCHS)

common-docker-tag-latest: $(TAG_DOCKER_ARCHS)

$(TAG_DOCKER_ARCHS): common-docker-tag-latest-%:

@for variant in $(DOCKERFILE_VARIANTS_WITH_NAMES); do \

dockerfile=$${variant#*:}; \

variant_name=$${variant%%:*}; \

if [ "$$dockerfile" != "Dockerfile" ] || [ "$$variant_name" != "default" ]; then \

echo "Tagging $$variant_name variant for linux-$* as latest"; \

docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)-$$variant_name" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:latest-$$variant_name"; \

docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)-$$variant_name" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:v$(DOCKER_MAJOR_VERSION_TAG)-$$variant_name"; \

fi; \

if [ "$$dockerfile" = "Dockerfile" ]; then \

echo "Tagging default variant ($$variant_name) for linux-$* as latest"; \

docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:latest"; \

docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:v$(DOCKER_MAJOR_VERSION_TAG)"; \

fi; \

done

.PHONY: common-docker-manifest

common-docker-manifest:

@for variant in $(DOCKERFILE_VARIANTS_WITH_NAMES); do \

dockerfile=$${variant#*:}; \

variant_name=$${variant%%:*}; \

if [ "$$dockerfile" != "Dockerfile" ] || [ "$$variant_name" != "default" ]; then \

echo "Creating manifest for $$variant_name variant"; \

refs=""; \

for arch in $(DOCKER_ARCHS); do \

refs="$$refs $(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$$arch:$(SANITIZED_DOCKER_IMAGE_TAG)-$$variant_name"; \

done; \

if [ -z "$$refs" ]; then \

echo "Skipping manifest for $$variant_name variant (no supported architectures)"; \

continue; \

fi; \

DOCKER_CLI_EXPERIMENTAL=enabled docker manifest create -a "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(SANITIZED_DOCKER_IMAGE_TAG)-$$variant_name" $$refs; \

DOCKER_CLI_EXPERIMENTAL=enabled docker manifest push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(SANITIZED_DOCKER_IMAGE_TAG)-$$variant_name"; \

fi; \

if [ "$$dockerfile" = "Dockerfile" ]; then \

echo "Creating default variant ($$variant_name) manifest"; \

refs=""; \

for arch in $(DOCKER_ARCHS); do \

refs="$$refs $(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$$arch:$(SANITIZED_DOCKER_IMAGE_TAG)"; \

done; \

if [ -z "$$refs" ]; then \

echo "Skipping default variant manifest (no supported architectures)"; \

continue; \

fi; \

DOCKER_CLI_EXPERIMENTAL=enabled docker manifest create -a "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(SANITIZED_DOCKER_IMAGE_TAG)" $$refs; \

DOCKER_CLI_EXPERIMENTAL=enabled docker manifest push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(SANITIZED_DOCKER_IMAGE_TAG)"; \

fi; \

if [ "$(DOCKER_IMAGE_TAG)" = "latest" ]; then \

if [ "$$dockerfile" != "Dockerfile" ] || [ "$$variant_name" != "default" ]; then \

echo "Creating manifest for $$variant_name variant version tag"; \

refs=""; \

for arch in $(DOCKER_ARCHS); do \

refs="$$refs $(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$$arch:v$(DOCKER_MAJOR_VERSION_TAG)-$$variant_name"; \

done; \

if [ -z "$$refs" ]; then \

echo "Skipping version-tag manifest for $$variant_name variant (no supported architectures)"; \

continue; \

fi; \

DOCKER_CLI_EXPERIMENTAL=enabled docker manifest create -a "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):v$(DOCKER_MAJOR_VERSION_TAG)-$$variant_name" $$refs; \

DOCKER_CLI_EXPERIMENTAL=enabled docker manifest push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):v$(DOCKER_MAJOR_VERSION_TAG)-$$variant_name"; \

fi; \

if [ "$$dockerfile" = "Dockerfile" ]; then \

echo "Creating default variant version tag manifest"; \

refs=""; \

for arch in $(DOCKER_ARCHS); do \

refs="$$refs $(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$$arch:v$(DOCKER_MAJOR_VERSION_TAG)"; \

done; \

if [ -z "$$refs" ]; then \

echo "Skipping default variant version-tag manifest (no supported architectures)"; \

continue; \

fi; \

DOCKER_CLI_EXPERIMENTAL=enabled docker manifest create -a "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):v$(DOCKER_MAJOR_VERSION_TAG)" $$refs; \

DOCKER_CLI_EXPERIMENTAL=enabled docker manifest push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):v$(DOCKER_MAJOR_VERSION_TAG)"; \

fi; \

fi; \

done

.PHONY: promu

promu: $(PROMU)

$(PROMU):

$(eval PROMU_TMP := $(shell mktemp -d))

curl -s -L $(PROMU_URL) | tar -xvzf - -C $(PROMU_TMP)

mkdir -p $(FIRST_GOPATH)/bin

cp $(PROMU_TMP)/promu-$(PROMU_VERSION).$(GO_BUILD_PLATFORM)/promu $(FIRST_GOPATH)/bin/promu

rm -r $(PROMU_TMP)

.PHONY: common-proto

common-proto:

@echo ">> generating code from proto files"

@./scripts/genproto.sh

ifdef GOLANGCI_LINT

$(GOLANGCI_LINT):

mkdir -p $(FIRST_GOPATH)/bin

curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/$(GOLANGCI_LINT_VERSION)/install.sh \

| sed -e '/install -d/d' \

| sh -s -- -b $(FIRST_GOPATH)/bin $(GOLANGCI_LINT_VERSION)

endif

.PHONY: common-print-golangci-lint-version

common-print-golangci-lint-version:

@echo $(GOLANGCI_LINT_VERSION)

.PHONY: precheck

precheck::

define PRECHECK_COMMAND_template =

precheck:: $(1)_precheck

PRECHECK_COMMAND_$(1) ?= $(1) $$(strip $$(PRECHECK_OPTIONS_$(1)))

.PHONY: $(1)_precheck

$(1)_precheck:

@if ! $$(PRECHECK_COMMAND_$(1)) 1>/dev/null 2>&1; then \

echo "Execution of '$$(PRECHECK_COMMAND_$(1))' command failed. Is $(1) installed?"; \

exit 1; \

fi

endef