Version commit hash

.github/workflows/build-images.yaml

@@ -46,6 +46,10 @@ jobs:
           image: ${{ env.OPERATOR_NAME }}
           tags: ${{ env.IMG_TAGS }}
           platforms: linux/amd64,linux/arm64
+          build-args: |
+            GIT_SHA=${{ github.sha }}
+            DIRTY=false
+
           dockerfiles: |
             ./Dockerfile
 
@@ -92,6 +96,9 @@ jobs:
           image: ${{ env.OPERATOR_NAME }}-bundle
           tags: ${{ needs.build.outputs.build-tags }}
           platforms: linux/amd64,linux/arm64
+          build-args: |
+            GIT_SHA=${{ github.sha }}
+            DIRTY=false
           dockerfiles: |
             ./bundle.Dockerfile
 

Dockerfile

@@ -3,6 +3,13 @@ FROM golang:1.21 as builder
 ARG TARGETOS
 ARG TARGETARCH
 
+ARG GIT_SHA
+ARG DIRTY
+
+ENV GIT_SHA=${GIT_SHA:-unknown}
+ENV DIRTY=${DIRTY:-unknown}
+
+
 WORKDIR /workspace
 # Copy the Go Modules manifests
 COPY go.mod go.mod
@@ -15,13 +22,15 @@ RUN go mod download
 COPY cmd/main.go cmd/main.go
 COPY api/ api/
 COPY internal/ internal/
+COPY version/ version/
+COPY pkg/ pkg/
 
 # Build
 # the GOARCH has not a default value to allow the binary be built according to the host where the command
 # was called. For example, if we call make docker-build in a local env which has the Apple Silicon M1 SO
 # the docker BUILDPLATFORM arg will be linux/arm64 when for Apple x86 it will be linux/amd64. Therefore,
 # by leaving it empty we can ensure that the container and binary shipped on it will have the same platform.
-RUN CGO_ENABLED=0 GOOS=${TARGETOS:-linux} GOARCH=${TARGETARCH} go build -a -o manager cmd/main.go
+RUN CGO_ENABLED=0 GOOS=${TARGETOS:-linux} GOARCH=${TARGETARCH} go build -ldflags "-X main.gitSHA=${GIT_SHA} -X main.dirty=${DIRTY}" -a -o manager cmd/main.go
 
 # Use distroless as minimal base image to package the manager binary
 # Refer to https://github.com/GoogleContainerTools/distroless for more details

Makefile

@@ -214,19 +214,25 @@ local-deploy-namespaced: docker-build kind-load-image ## Deploy the dns operator
 ##@ Build
 
 .PHONY: build
+build: GIT_SHA=$(shell git rev-parse HEAD || echo "unknown") 
+build: DIRTY=$(shell hack/check-git-dirty.sh || echo "unknown")
 build: manifests generate fmt vet ## Build manager binary.
-	go build -o bin/manager cmd/main.go
+	go build -ldflags "-X main.gitSHA=${GIT_SHA} -X main.dirty=${DIRTY}" -o bin/manager cmd/main.go
 
 .PHONY: run
+run: GIT_SHA=$(shell git rev-parse HEAD || echo "unknown") 
+run: DIRTY=$(shell hack/check-git-dirty.sh || echo "unknown")
 run: manifests generate fmt vet ## Run a controller from your host.
-	go run ./cmd/main.go --zap-devel --provider inmemory,aws,google,azure
+	go run -ldflags "-X main.gitSHA=${GIT_SHA} -X main.dirty=${DIRTY}" ./cmd/main.go --zap-devel --provider inmemory,aws,google,azure
 
 # If you wish built the manager image targeting other platforms you can use the --platform flag.
 # (i.e. docker build --platform linux/arm64 ). However, you must enable docker buildKit for it.
 # More info: https://docs.docker.com/develop/develop-images/build_enhancements/
 .PHONY: docker-build
+docker-build: GIT_SHA=$(shell git rev-parse HEAD || echo "unknown") 
+docker-build: DIRTY=$(shell hack/check-git-dirty.sh || echo "unknown")
 docker-build: ## Build docker image with the manager.
-	$(CONTAINER_TOOL) build -t ${IMG} .
+	$(CONTAINER_TOOL) build -t ${IMG} . --build-arg GIT_SHA=$(GIT_SHA) --build-arg DIRTY=$(DIRTY)
 
 .PHONY: docker-push
 docker-push: ## Push docker image with the manager.

cmd/main.go

@@ -20,13 +20,15 @@ import (
 	"flag"
 	"fmt"
 	"os"
+	"runtime"
 	"strings"
 	"time"
 
-	"k8s.io/apimachinery/pkg/runtime"
+	k8sruntime "k8s.io/apimachinery/pkg/runtime"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
 	_ "k8s.io/client-go/plugin/pkg/client/auth"
+	"k8s.io/utils/env"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/cache"
 	"sigs.k8s.io/controller-runtime/pkg/healthz"
@@ -41,12 +43,18 @@ import (
 	_ "github.com/kuadrant/dns-operator/internal/provider/azure"
 	_ "github.com/kuadrant/dns-operator/internal/provider/google"
 	_ "github.com/kuadrant/dns-operator/internal/provider/inmemory"
+	"github.com/kuadrant/dns-operator/pkg/log"
+	"github.com/kuadrant/dns-operator/version"
 	//+kubebuilder:scaffold:imports
 )
 
 var (
-	scheme   = runtime.NewScheme()
+	scheme   = k8sruntime.NewScheme()
 	setupLog = ctrl.Log.WithName("setup")
+	logLevel = env.GetString("LOG_LEVEL", "info")
+	logMode  = env.GetString("LOG_MODE", "production")
+	gitSHA   string // pass ldflag here to display gitSHA hash
+	dirty    string // must be string as passed in by ldflag to determine display .
 )
 
 const (
@@ -60,9 +68,24 @@ func init() {
 
 	utilruntime.Must(v1alpha1.AddToScheme(scheme))
 	//+kubebuilder:scaffold:scheme
+
+	logger := log.NewLogger(
+		log.SetLevel(log.ToLevel(logLevel)),
+		log.SetMode(log.ToMode(logMode)),
+		log.WriteTo(os.Stdout),
+	)
+	log.SetLogger(logger)
+}
+
+func printControllerMetaInfo() {
+	setupLog.Info(fmt.Sprintf("go version: %s", runtime.Version()))
+	setupLog.Info(fmt.Sprintf("go os/arch: %s/%s", runtime.GOOS, runtime.GOARCH))
+	setupLog.Info("base logger", "log level", logLevel, "log mode", logMode)
+	setupLog.Info("", "version", version.Version, "commit", gitSHA, "dirty", dirty)
 }
 
 func main() {
+	printControllerMetaInfo()
 	var metricsAddr string
 	var enableLeaderElection bool
 	var probeAddr string

go.mod

@@ -79,7 +79,7 @@ require (
 	github.com/stretchr/objx v0.5.0 // indirect
 	go.opencensus.io v0.24.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	go.uber.org/zap v1.26.0 // indirect
+	go.uber.org/zap v1.26.0
 	golang.org/x/crypto v0.21.0 // indirect
 	golang.org/x/sys v0.18.0 // indirect
 	golang.org/x/term v0.18.0 // indirect
@@ -93,9 +93,10 @@ require (
 	google.golang.org/protobuf v1.33.0 // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
+	gotest.tools v2.2.0+incompatible
 	k8s.io/apiextensions-apiserver v0.28.3 // indirect
 	k8s.io/component-base v0.28.3 // indirect
-	k8s.io/klog/v2 v2.100.1 // indirect
+	k8s.io/klog/v2 v2.100.1
 	k8s.io/kube-openapi v0.0.0-20231010175941-2dd684a91f00 // indirect
 	sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect
 	sigs.k8s.io/structured-merge-diff/v4 v4.3.0 // indirect

go.sum

@@ -379,6 +379,8 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
+gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 k8s.io/api v0.28.3 h1:Gj1HtbSdB4P08C8rs9AR94MfSGpRhJgsS+GF9V26xMM=

hack/check-git-dirty.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+if ! command -v git &>/dev/null 
+then
+    echo "git not found..." >&2
+    exit 1
+fi
+
+if output=$(git diff --stat 2>/dev/null)
+then
+[ -n "$output" ] && echo "true" || echo "false"
+else
+    # Not a git repository
+    exit 1
+fi

pkg/log/log.go

@@ -0,0 +1,159 @@
+/*
+Copyright 2021 Red Hat, Inc.
+
+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 log
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/go-logr/logr"
+	"go.uber.org/zap/zapcore"
+
+	"k8s.io/klog/v2"
+	ctrl "sigs.k8s.io/controller-runtime"
+	ctrllog "sigs.k8s.io/controller-runtime/pkg/log"
+	"sigs.k8s.io/controller-runtime/pkg/log/zap"
+)
+
+var (
+	// Log is the base logger
+	Log logr.Logger = logr.New(ctrllog.NullLogSink{})
+)
+
+// Level configures the verbosity of the logging.
+type Level zapcore.Level
+
+const (
+	// DebugLevel logs are typically voluminous, and are usually disabled in production.
+	DebugLevel = Level(zapcore.DebugLevel)
+	// InfoLevel is the default logging priority.
+	InfoLevel = Level(zapcore.InfoLevel)
+	// WarnLevel logs are more important than Info, but don't need individual human review.
+	WarnLevel = Level(zapcore.WarnLevel)
+	// ErrorLevel logs are high-priority. If an application is running smoothly,
+	// it shouldn't generate any error-level logs.
+	ErrorLevel = Level(zapcore.ErrorLevel)
+	// DPanicLevel logs are particularly important errors. In development the
+	// logger panics after writing the message.
+	DPanicLevel = Level(zapcore.DPanicLevel)
+	// PanicLevel logs a message, then panics.
+	PanicLevel = Level(zapcore.PanicLevel)
+	// FatalLevel logs a message, then calls os.Exit(1).
+	FatalLevel = Level(zapcore.FatalLevel)
+)
+
+// ToLevel converts a string to a log level.
+func ToLevel(level string) Level {
+	var l zapcore.Level
+	err := l.UnmarshalText([]byte(level))
+	if err != nil {
+		panic(err)
+	}
+	return Level(l)
+}
+
+// Mode defines the log output mode.
+type Mode int8
+
+const (
+	// ModeProd is the log mode for production.
+	ModeProd Mode = iota
+	// ModeDev is for more human-readable outputs, extra stack traces
+	// and logging info. (aka Zap's "development config".)
+	// https://pkg.go.dev/sigs.k8s.io/controller-runtime/pkg/log/zap#UseDevMode
+	ModeDev
+)
+
+// ToMode converts a string to a log mode.
+// Use either 'production' for `LogModeProd` or 'development' for `LogModeDev`.
+func ToMode(mode string) Mode {
+	switch strings.ToLower(mode) {
+	case "production":
+		return ModeProd
+	case "development":
+		return ModeDev
+	default:
+		panic(fmt.Sprintf("unknown log mode: %s", mode))
+	}
+}
+
+// Opts allows to manipulate Options.
+type Opts func(*Options)
+
+// Options contains all possible settings.
+type Options struct {
+	// LogLevel configures the verbosity of the logging.
+	LogLevel Level
+	// LogMode defines the log output mode.
+	LogMode Mode
+	// DestWriter controls the destination of the log output.  Defaults to
+	// os.Stderr.
+	DestWriter io.Writer
+}
+
+// SetLogger sets a concrete logging implementation for all deferred Loggers.
+// Being top level application and not a library or dependency,
+// let's delegation logger used by any dependency
+func SetLogger(logger logr.Logger) {
+	Log = logger
+
+	ctrl.SetLogger(logger) // fulfills `logger` as the de facto logger used by controller-runtime
+	klog.SetLogger(logger)
+}
+
+// WriteTo configures the logger to write to the given io.Writer, instead of standard error.
+// See Options.DestWriter.
+func WriteTo(out io.Writer) Opts {
+	return func(o *Options) {
+		o.DestWriter = out
+	}
+}
+
+// SetLevel sets Options.LogLevel, which configures the the minimum enabled logging level e.g Debug, Info.
+func SetLevel(level Level) func(o *Options) {
+	return func(o *Options) {
+		o.LogLevel = level
+	}
+}
+
+// SetMode sets Options.LogMode, which configures to use (or not use) development mode
+func SetMode(mode Mode) func(o *Options) {
+	return func(o *Options) {
+		o.LogMode = mode
+	}
+}
+
+// NewLogger creates new Logger based on controller runtime zap logger
+func NewLogger(opts ...Opts) logr.Logger {
+	o := &Options{}
+	for _, opt := range opts {
+		opt(o)
+	}
+
+	// defaults
+	if o.DestWriter == nil {
+		o.DestWriter = os.Stderr
+	}
+
+	return zap.New(
+		zap.Level(zapcore.Level(o.LogLevel)),
+		zap.UseDevMode(o.LogMode == ModeDev),
+		zap.WriteTo(o.DestWriter),
+	)
+}