Update index.md (#995)

Add sponsor link at the bottom

Dockerfile

@@ -34,9 +34,9 @@ RUN CGO_ENABLED=0 \
     GOPROXY=${GOPROXY} \
     GOPRIVATE=${GOPRIVATE} \
     GO111MODULE=on \
-    go build -ldflags="-s -w -X github.com/stakater/Reloader/pkg/metainfo.Version=${VERSION} \
-         -X github.com/stakater/Reloader/pkg/metainfo.Commit=${COMMIT} \
-         -X github.com/stakater/Reloader/pkg/metainfo.BuildDate=${BUILD_DATE}" \
+    go build -ldflags="-s -w -X github.com/stakater/Reloader/pkg/common.Version=${VERSION} \
+         -X github.com/stakater/Reloader/pkg/common.Commit=${COMMIT} \
+         -X github.com/stakater/Reloader/pkg/common.BuildDate=${BUILD_DATE}" \
         -installsuffix 'static' -mod=mod -a -o manager ./
 
 # Use distroless as minimal base image to package the manager binary

README.md

@@ -358,6 +358,13 @@ These flags allow you to redefine annotation keys used in your workloads or reso
 | `--pause-deployment-annotation` | Overrides `deployment.reloader.stakater.com/pause-period` |
 | `--pause-deployment-time-annotation` | Overrides `deployment.reloader.stakater.com/paused-at` |
 
+### 5. 🕷️ Debugging
+
+| Flag | Description |
+|---  |-------------|
+| `--enable-pprof` | Enables `pprof` for profiling |
+| `--pprof-addr` | Address to start `pprof` server on. Default is `:6060` |
+
 ## Compatibility
 
 Reloader is compatible with Kubernetes >= 1.19

deployments/kubernetes/chart/reloader/Chart.yaml

@@ -2,7 +2,7 @@ apiVersion: v1
 name: reloader
 description: Reloader chart that runs on kubernetes
 version: 2.2.0
-appVersion: v1.4.5
+appVersion: v1.4.6
 keywords:
   - Reloader
   - kubernetes

deployments/kubernetes/chart/reloader/README.md

@@ -57,6 +57,8 @@ helm uninstall {{RELEASE_NAME}} -n {{NAMESPACE}}
 | `reloader.logFormat`                | Set type of log format. Value could be either `json` or `""`                                                                                        | string      | `""`      |
 | `reloader.watchGlobally`            | Allow Reloader to watch in all namespaces (`true`) or just in a single namespace (`false`)                                                          | boolean     | `true`    |
 | `reloader.enableHA`                 | Enable leadership election allowing you to run multiple replicas                                                                                    | boolean     | `false`   |
+| `reloader.enablePProf`              | Enables pprof for profiling | boolean | `false` |
+| `reloader.pprofAddr` | Address to start pprof server on | string | `:6060` | 
 | `reloader.readOnlyRootFileSystem`   | Enforce readOnlyRootFilesystem                                                                                                                      | boolean     | `false`   |
 | `reloader.legacy.rbac`              |                                                                                                                                                     | boolean     | `false`   |
 | `reloader.matchLabels`              | Pod labels to match                                                                                                                                 | map         | `{}`      |
@@ -82,6 +84,8 @@ helm uninstall {{RELEASE_NAME}} -n {{NAMESPACE}}
 | `reloader.deployment.resources`                 | Set container requests and limits (e.g. CPU or memory)                                                                                                      | map    | `{}`              |
 | `reloader.deployment.pod.annotations`           | Set annotations for pod                                                                                                                                     | map    | `{}`              |
 | `reloader.deployment.priorityClassName`         | Set priority class for pod in cluster                                                                                                                       | string | `""`              |
+| `reloader.deployment.volumeMounts`              | Mount volume                                                                                                                                                | array  | `[]`              |
+| `reloader.deployment.volumes`                   | Add volume to a pod                                                                                                                                         | array  | `[]`              |
 
 ### Other Reloader Parameters
 
@@ -95,8 +99,6 @@ helm uninstall {{RELEASE_NAME}} -n {{NAMESPACE}}
 | `reloader.podMonitor.enabled`          | Enable to scrape Reloader's Prometheus metrics                  | boolean | `false` |
 | `reloader.podDisruptionBudget.enabled` | Limit the number of pods of a replicated application            | boolean | `false` |
 | `reloader.netpol.enabled`              |                                                                 | boolean | `false` |
-| `reloader.volumeMounts`                | Mount volume                                                    | array   | `[]`    |
-| `reloader.volumes`                     | Add volume to a pod                                             | array   | `[]`    |
 | `reloader.webhookUrl`                  | Add webhook to Reloader                                         | string  | `""`    |
 
 ## ⚙️ Helm Chart Configuration Notes

deployments/kubernetes/chart/reloader/templates/deployment.yaml

@@ -229,6 +229,12 @@ spec:
           {{- if .Values.reloader.resourceLabelSelector }}
           - "--resource-label-selector={{ .Values.reloader.resourceLabelSelector }}"
           {{- end }}
+          {{- if .Values.reloader.enablePProf }}
+          - "--enable-pprof"
+          {{- if and .Values.reloader.pprofAddr }}
+          - "--pprof-addr={{ .Values.reloader.pprofAddr }}"
+          {{- end }}
+          {{- end }}
           {{- if .Values.reloader.custom_annotations }}
             {{- if .Values.reloader.custom_annotations.configmap }}
           - "--configmap-annotation"
@@ -257,6 +263,14 @@ spec:
             {{- if .Values.reloader.custom_annotations.match }}
           - "--search-match-annotation"
           - "{{ .Values.reloader.custom_annotations.match }}"
+            {{- end }}
+            {{- if .Values.reloader.custom_annotations.pausePeriod }}
+          - "--pause-deployment-annotation"
+          - "{{ .Values.reloader.custom_annotations.pausePeriod }}"
+            {{- end }}
+            {{- if .Values.reloader.custom_annotations.pauseTime }}
+          - "--pause-deployment-annotation"
+          - "{{ .Values.reloader.custom_annotations.pauseTime }}"
             {{- end }}
             {{- if .Values.reloader.webhookUrl }}
           - "--webhook-url"

deployments/kubernetes/chart/reloader/values.yaml

@@ -17,7 +17,7 @@ fullnameOverride: ""
 image:
   name: stakater/reloader
   repository: ghcr.io/stakater/reloader
-  tag: v1.4.5
+  tag: v1.4.6
   # digest: sha256:1234567
   pullPolicy: IfNotPresent
 
@@ -41,6 +41,10 @@ reloader:
   watchGlobally: true
   # Set to true to enable leadership election allowing you to run multiple replicas
   enableHA: false
+  # Set to true to enable pprof for profiling
+  enablePProf: false
+  # Address to start pprof server on. Default is ":6060"
+  pprofAddr: ":6060"
   # Set to true if you have a pod security policy that enforces readOnlyRootFilesystem
   readOnlyRootFileSystem: false
   legacy:
@@ -67,6 +71,9 @@ reloader:
     #           - key: "node-role.kubernetes.io/infra-worker"
     #             operator: "Exists"
     affinity: {}
+    
+    volumeMounts: []
+    volumes: []
 
     securityContext:
       runAsNonRoot: true
@@ -106,7 +113,7 @@ reloader:
     labels:
       provider: stakater
       group: com.stakater.platform
-      version: v1.4.5
+      version: v1.4.6
     # Support for extra environment variables.
     env:
       # Open supports Key value pair as environment variables.
@@ -337,8 +344,4 @@ reloader:
       # are applied during the life of a Pod. Possible values are "Off", "Initial", "Recreate", and "Auto".
       updateMode: Auto
 
-  volumeMounts: []
-
-  volumes: []
-
   webhookUrl: ""

docs/index.md

@@ -10,3 +10,17 @@ These are the key features of Reloader:
 1. Restart pod in a `rollout` on change in linked/related `ConfigMaps` or `Secrets`
 
 This site contains more details on how Reloader works. For an overview, please see the repository's [README file](https://github.com/stakater/Reloader/blob/master/README.md).
+
+---
+
+<div align="center">
+
+[![💖 Sponsor our work](https://img.shields.io/badge/Sponsor%20Our%20Work-FF8C00?style=for-the-badge&logo=github-sponsors&logoColor=white)](https://github.com/sponsors/stakater?utm_source=docs&utm_medium=footer&utm_campaign=reloader)
+
+<p>
+Your support funds maintenance, security updates, and new features for Reloader, plus continued investment in other open source tools.
+</p>
+
+</div>
+
+---

internal/pkg/cmd/reloader.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	_ "net/http/pprof"
 	"os"
 	"strings"
 
@@ -19,6 +20,7 @@ import (
 	"github.com/stakater/Reloader/internal/pkg/metrics"
 	"github.com/stakater/Reloader/internal/pkg/options"
 	"github.com/stakater/Reloader/internal/pkg/util"
+	"github.com/stakater/Reloader/pkg/common"
 	"github.com/stakater/Reloader/pkg/kube"
 )
 
@@ -101,6 +103,7 @@ func getHAEnvs() (string, string) {
 }
 
 func startReloader(cmd *cobra.Command, args []string) {
+	common.GetCommandLineOptions()
 	err := configureLogging(options.LogFormat, options.LogLevel)
 	if err != nil {
 		logrus.Warn(err)
@@ -188,8 +191,19 @@ func startReloader(cmd *cobra.Command, args []string) {
 		go leadership.RunLeaderElection(lock, ctx, cancel, podName, controllers)
 	}
 
-	util.PublishMetaInfoConfigmap(clientset)
+	common.PublishMetaInfoConfigmap(clientset)
+
+	if options.EnablePProf {
+		go startPProfServer()
+	}
 
 	leadership.SetupLivenessEndpoint()
 	logrus.Fatal(http.ListenAndServe(constants.DefaultHttpListenAddr, nil))
 }
+
+func startPProfServer() {
+	logrus.Infof("Starting pprof server on %s", options.PProfAddr)
+	if err := http.ListenAndServe(options.PProfAddr, nil); err != nil {
+		logrus.Errorf("Failed to start pprof server: %v", err)
+	}
+}

internal/pkg/handler/upgrade.go

@@ -7,9 +7,6 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"regexp"
-	"strconv"
-	"strings"
 
 	"github.com/parnurzeal/gorequest"
 	"github.com/prometheus/client_golang/prometheus"
@@ -20,6 +17,7 @@ import (
 	"github.com/stakater/Reloader/internal/pkg/metrics"
 	"github.com/stakater/Reloader/internal/pkg/options"
 	"github.com/stakater/Reloader/internal/pkg/util"
+	"github.com/stakater/Reloader/pkg/common"
 	"github.com/stakater/Reloader/pkg/kube"
 	app "k8s.io/api/apps/v1"
 	v1 "k8s.io/api/core/v1"
@@ -264,143 +262,76 @@ func upgradeResource(clients kube.Clients, config util.Config, upgradeFuncs call
 			return err
 		}
 	}
+	annotations := upgradeFuncs.AnnotationsFunc(resource)
+	podAnnotations := upgradeFuncs.PodAnnotationsFunc(resource)
+	result := common.ShouldReload(config, upgradeFuncs.ResourceType, annotations, podAnnotations, common.GetCommandLineOptions())
 
-	ignoreResourceAnnotatonValue := config.ResourceAnnotations[options.IgnoreResourceAnnotation]
-	if ignoreResourceAnnotatonValue == "true" {
+	if !result.ShouldReload {
+		logrus.Debugf("No changes detected in '%s' of type '%s' in namespace '%s'", config.ResourceName, config.Type, config.Namespace)
+		return nil
+	}
+
+	strategyResult := strategy(upgradeFuncs, resource, config, result.AutoReload)
+
+	if strategyResult.Result != constants.Updated {
 		return nil
 	}
 
 	// find correct annotation and update the resource
-	annotations := upgradeFuncs.AnnotationsFunc(resource)
-	annotationValue, found := annotations[config.Annotation]
-	searchAnnotationValue, foundSearchAnn := annotations[options.AutoSearchAnnotation]
-	reloaderEnabledValue, foundAuto := annotations[options.ReloaderAutoAnnotation]
-	typedAutoAnnotationEnabledValue, foundTypedAuto := annotations[config.TypedAutoAnnotation]
-	excludeConfigmapAnnotationValue, foundExcludeConfigmap := annotations[options.ConfigmapExcludeReloaderAnnotation]
-	excludeSecretAnnotationValue, foundExcludeSecret := annotations[options.SecretExcludeReloaderAnnotation]
 	pauseInterval, foundPauseInterval := annotations[options.PauseDeploymentAnnotation]
 
-	if !found && !foundAuto && !foundTypedAuto && !foundSearchAnn {
-		annotations = upgradeFuncs.PodAnnotationsFunc(resource)
-		annotationValue = annotations[config.Annotation]
-		searchAnnotationValue = annotations[options.AutoSearchAnnotation]
-		reloaderEnabledValue = annotations[options.ReloaderAutoAnnotation]
-		typedAutoAnnotationEnabledValue = annotations[config.TypedAutoAnnotation]
-	}
-
-	isResourceExcluded := false
-
-	switch config.Type {
-	case constants.ConfigmapEnvVarPostfix:
-		if foundExcludeConfigmap {
-			isResourceExcluded = checkIfResourceIsExcluded(config.ResourceName, excludeConfigmapAnnotationValue)
-		}
-	case constants.SecretEnvVarPostfix:
-		if foundExcludeSecret {
-			isResourceExcluded = checkIfResourceIsExcluded(config.ResourceName, excludeSecretAnnotationValue)
-		}
-	}
-
-	if isResourceExcluded {
-		return nil
-	}
-
-	strategyResult := InvokeStrategyResult{constants.NotUpdated, nil}
-	reloaderEnabled, _ := strconv.ParseBool(reloaderEnabledValue)
-	typedAutoAnnotationEnabled, _ := strconv.ParseBool(typedAutoAnnotationEnabledValue)
-	if reloaderEnabled || typedAutoAnnotationEnabled || reloaderEnabledValue == "" && typedAutoAnnotationEnabledValue == "" && options.AutoReloadAll {
-		strategyResult = strategy(upgradeFuncs, resource, config, true)
-	}
-
-	if strategyResult.Result != constants.Updated && annotationValue != "" {
-		values := strings.Split(annotationValue, ",")
-		for _, value := range values {
-			value = strings.TrimSpace(value)
-			re := regexp.MustCompile("^" + value + "$")
-			if re.Match([]byte(config.ResourceName)) {
-				strategyResult = strategy(upgradeFuncs, resource, config, false)
-				if strategyResult.Result == constants.Updated {
-					break
-				}
-			}
-		}
-	}
-
-	if strategyResult.Result != constants.Updated && searchAnnotationValue == "true" {
-		matchAnnotationValue := config.ResourceAnnotations[options.SearchMatchAnnotation]
-		if matchAnnotationValue == "true" {
-			strategyResult = strategy(upgradeFuncs, resource, config, true)
-		}
-	}
-	if strategyResult.Result == constants.Updated {
-		if foundPauseInterval {
-			deployment, ok := resource.(*app.Deployment)
-			if !ok {
-				logrus.Warnf("Annotation '%s' only applicable for deployments", options.PauseDeploymentAnnotation)
-			} else {
-				_, err = PauseDeployment(deployment, clients, config.Namespace, pauseInterval)
-				if err != nil {
-					logrus.Errorf("Failed to pause deployment '%s' in namespace '%s': %v", resourceName, config.Namespace, err)
-					return err
-				}
-			}
-		}
-		var err error
-		if upgradeFuncs.SupportsPatch && strategyResult.Patch != nil {
-			err = upgradeFuncs.PatchFunc(clients, config.Namespace, resource, strategyResult.Patch.Type, strategyResult.Patch.Bytes)
+	if foundPauseInterval {
+		deployment, ok := resource.(*app.Deployment)
+		if !ok {
+			logrus.Warnf("Annotation '%s' only applicable for deployments", options.PauseDeploymentAnnotation)
 		} else {
-			err = upgradeFuncs.UpdateFunc(clients, config.Namespace, resource)
+			_, err = PauseDeployment(deployment, clients, config.Namespace, pauseInterval)
+			if err != nil {
+				logrus.Errorf("Failed to pause deployment '%s' in namespace '%s': %v", resourceName, config.Namespace, err)
+				return err
+			}
 		}
+	}
 
-		if err != nil {
-			message := fmt.Sprintf("Update for '%s' of type '%s' in namespace '%s' failed with error %v", resourceName, upgradeFuncs.ResourceType, config.Namespace, err)
-			logrus.Errorf("Update for '%s' of type '%s' in namespace '%s' failed with error %v", resourceName, upgradeFuncs.ResourceType, config.Namespace, err)
+	if upgradeFuncs.SupportsPatch && strategyResult.Patch != nil {
+		err = upgradeFuncs.PatchFunc(clients, config.Namespace, resource, strategyResult.Patch.Type, strategyResult.Patch.Bytes)
+	} else {
+		err = upgradeFuncs.UpdateFunc(clients, config.Namespace, resource)
+	}
 
-			collectors.Reloaded.With(prometheus.Labels{"success": "false"}).Inc()
-			collectors.ReloadedByNamespace.With(prometheus.Labels{"success": "false", "namespace": config.Namespace}).Inc()
-			if recorder != nil {
-				recorder.Event(resource, v1.EventTypeWarning, "ReloadFail", message)
-			}
-			return err
-		} else {
-			message := fmt.Sprintf("Changes detected in '%s' of type '%s' in namespace '%s'", config.ResourceName, config.Type, config.Namespace)
-			message += fmt.Sprintf(", Updated '%s' of type '%s' in namespace '%s'", resourceName, upgradeFuncs.ResourceType, config.Namespace)
+	if err != nil {
+		message := fmt.Sprintf("Update for '%s' of type '%s' in namespace '%s' failed with error %v", resourceName, upgradeFuncs.ResourceType, config.Namespace, err)
+		logrus.Errorf("Update for '%s' of type '%s' in namespace '%s' failed with error %v", resourceName, upgradeFuncs.ResourceType, config.Namespace, err)
 
-			logrus.Infof("Changes detected in '%s' of type '%s' in namespace '%s'; updated '%s' of type '%s' in namespace '%s'", config.ResourceName, config.Type, config.Namespace, resourceName, upgradeFuncs.ResourceType, config.Namespace)
+		collectors.Reloaded.With(prometheus.Labels{"success": "false"}).Inc()
+		collectors.ReloadedByNamespace.With(prometheus.Labels{"success": "false", "namespace": config.Namespace}).Inc()
+		if recorder != nil {
+			recorder.Event(resource, v1.EventTypeWarning, "ReloadFail", message)
+		}
+		return err
+	} else {
+		message := fmt.Sprintf("Changes detected in '%s' of type '%s' in namespace '%s'", config.ResourceName, config.Type, config.Namespace)
+		message += fmt.Sprintf(", Updated '%s' of type '%s' in namespace '%s'", resourceName, upgradeFuncs.ResourceType, config.Namespace)
 
-			collectors.Reloaded.With(prometheus.Labels{"success": "true"}).Inc()
-			collectors.ReloadedByNamespace.With(prometheus.Labels{"success": "true", "namespace": config.Namespace}).Inc()
-			alert_on_reload, ok := os.LookupEnv("ALERT_ON_RELOAD")
-			if recorder != nil {
-				recorder.Event(resource, v1.EventTypeNormal, "Reloaded", message)
-			}
-			if ok && alert_on_reload == "true" {
-				msg := fmt.Sprintf(
-					"Reloader detected changes in *%s* of type *%s* in namespace *%s*. Hence reloaded *%s* of type *%s* in namespace *%s*",
-					config.ResourceName, config.Type, config.Namespace, resourceName, upgradeFuncs.ResourceType, config.Namespace)
-				alert.SendWebhookAlert(msg)
-			}
+		logrus.Infof("Changes detected in '%s' of type '%s' in namespace '%s'; updated '%s' of type '%s' in namespace '%s'", config.ResourceName, config.Type, config.Namespace, resourceName, upgradeFuncs.ResourceType, config.Namespace)
+
+		collectors.Reloaded.With(prometheus.Labels{"success": "true"}).Inc()
+		collectors.ReloadedByNamespace.With(prometheus.Labels{"success": "true", "namespace": config.Namespace}).Inc()
+		alert_on_reload, ok := os.LookupEnv("ALERT_ON_RELOAD")
+		if recorder != nil {
+			recorder.Event(resource, v1.EventTypeNormal, "Reloaded", message)
+		}
+		if ok && alert_on_reload == "true" {
+			msg := fmt.Sprintf(
+				"Reloader detected changes in *%s* of type *%s* in namespace *%s*. Hence reloaded *%s* of type *%s* in namespace *%s*",
+				config.ResourceName, config.Type, config.Namespace, resourceName, upgradeFuncs.ResourceType, config.Namespace)
+			alert.SendWebhookAlert(msg)
 		}
 	}
 
 	return nil
 }
 
-func checkIfResourceIsExcluded(resourceName, excludedResources string) bool {
-	if excludedResources == "" {
-		return false
-	}
-
-	excludedResourcesList := strings.Split(excludedResources, ",")
-	for _, excludedResource := range excludedResourcesList {
-		if strings.TrimSpace(excludedResource) == resourceName {
-			return true
-		}
-	}
-
-	return false
-}
-
 func getVolumeMountName(volumes []v1.Volume, mountType string, volumeName string) string {
 	for i := range volumes {
 		if mountType == constants.ConfigmapEnvVarPostfix {

internal/pkg/handler/upgrade_test.go

@@ -4125,6 +4125,13 @@ func testPausingDeployment(t *testing.T, reloadStrategy string, testName string,
 
 	_ = PerformAction(clients, config, deploymentFuncs, collectors, nil, invokeReloadStrategy)
 
+	// Wait for deployment to have paused-at annotation
+	logrus.Infof("Waiting for deployment %s to have paused-at annotation", testName)
+	err := waitForDeploymentPausedAtAnnotation(clients, deploymentFuncs, config.Namespace, testName, 30*time.Second)
+	if err != nil {
+		t.Errorf("Failed to wait for deployment paused-at annotation: %v", err)
+	}
+
 	if promtestutil.ToFloat64(collectors.Reloaded.With(labelSucceeded)) != 1 {
 		t.Errorf("Counter was not increased")
 	}
@@ -4185,3 +4192,25 @@ func isDeploymentPaused(deployments []runtime.Object, deploymentName string) (bo
 	}
 	return IsPaused(deployment), nil
 }
+
+// waitForDeploymentPausedAtAnnotation waits for a deployment to have the pause-period annotation
+func waitForDeploymentPausedAtAnnotation(clients kube.Clients, deploymentFuncs callbacks.RollingUpgradeFuncs, namespace, deploymentName string, timeout time.Duration) error {
+	start := time.Now()
+
+	for time.Since(start) < timeout {
+		items := deploymentFuncs.ItemsFunc(clients, namespace)
+		deployment, err := FindDeploymentByName(items, deploymentName)
+		if err == nil {
+			annotations := deployment.GetAnnotations()
+			if annotations != nil {
+				if _, exists := annotations[options.PauseDeploymentTimeAnnotation]; exists {
+					return nil
+				}
+			}
+		}
+
+		time.Sleep(100 * time.Millisecond)
+	}
+
+	return fmt.Errorf("timeout waiting for deployment %s to have pause-period annotation", deploymentName)
+}

internal/pkg/options/flags.go

@@ -63,14 +63,19 @@ var (
 	EnableHA = false
 	// Url to send a request to instead of triggering a reload
 	WebhookUrl = ""
-
+	// ResourcesToIgnore is a list of resources to ignore when watching for changes
 	ResourcesToIgnore = []string{}
-
+	// NamespacesToIgnore is a list of namespace names to ignore when watching for changes
 	NamespacesToIgnore = []string{}
-
+	// NamespaceSelectors is a list of namespace selectors to watch for changes
 	NamespaceSelectors = []string{}
-
+	// ResourceSelectors is a list of resource selectors to watch for changes
 	ResourceSelectors = []string{}
+	// EnablePProf enables pprof for profiling
+	EnablePProf = false
+	// PProfAddr is the address to start pprof server on
+	// Default is :6060
+	PProfAddr = ":6060"
 )
 
 func ToArgoRolloutStrategy(s string) ArgoRolloutStrategy {

internal/pkg/util/config.go

@@ -6,7 +6,7 @@ import (
 	v1 "k8s.io/api/core/v1"
 )
 
-//Config contains rolling upgrade configuration parameters
+// Config contains rolling upgrade configuration parameters
 type Config struct {
 	Namespace           string
 	ResourceName        string

internal/pkg/util/util.go

@@ -2,11 +2,9 @@ package util
 
 import (
 	"bytes"
-	"context"
 	"encoding/base64"
 	"errors"
 	"fmt"
-	"os"
 	"sort"
 	"strings"
 
@@ -15,11 +13,8 @@ import (
 	"github.com/stakater/Reloader/internal/pkg/constants"
 	"github.com/stakater/Reloader/internal/pkg/crypto"
 	"github.com/stakater/Reloader/internal/pkg/options"
-	"github.com/stakater/Reloader/pkg/metainfo"
 	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/client-go/kubernetes"
 )
 
 // ConvertToEnvVarName converts the given text into a usable env var
@@ -64,43 +59,8 @@ func GetSHAfromSecret(data map[string][]byte) string {
 	return crypto.GenerateSHA(strings.Join(values, ";"))
 }
 
-func PublishMetaInfoConfigmap(clientset kubernetes.Interface) {
-	namespace := os.Getenv("RELOADER_NAMESPACE")
-	if namespace == "" {
-		logrus.Warn("RELOADER_NAMESPACE is not set, skipping meta info configmap creation")
-		return
-	}
-
-	metaInfo := &metainfo.MetaInfo{
-		BuildInfo:       *metainfo.NewBuildInfo(),
-		ReloaderOptions: *metainfo.GetReloaderOptions(),
-		DeploymentInfo: metav1.ObjectMeta{
-			Name:      os.Getenv("RELOADER_DEPLOYMENT_NAME"),
-			Namespace: namespace,
-		},
-	}
-
-	configMap := metaInfo.ToConfigMap()
-
-	if _, err := clientset.CoreV1().ConfigMaps(namespace).Get(context.Background(), configMap.Name, metav1.GetOptions{}); err == nil {
-		logrus.Info("Meta info configmap already exists, updating it")
-		_, err = clientset.CoreV1().ConfigMaps(namespace).Update(context.Background(), configMap, metav1.UpdateOptions{})
-		if err != nil {
-			logrus.Warn("Failed to update existing meta info configmap: ", err)
-		}
-		return
-	}
-
-	_, err := clientset.CoreV1().ConfigMaps(namespace).Create(context.Background(), configMap, metav1.CreateOptions{})
-	if err != nil {
-		logrus.Warn("Failed to create meta info configmap: ", err)
-	}
-}
-
 type List []string
 
-type Map map[string]string
-
 func (l *List) Contains(s string) bool {
 	for _, v := range *l {
 		if v == s {
@@ -134,6 +94,8 @@ func ConfigureReloaderFlags(cmd *cobra.Command) {
 	cmd.PersistentFlags().StringVar(&options.ReloadOnDelete, "reload-on-delete", "false", "Add support to watch delete events")
 	cmd.PersistentFlags().BoolVar(&options.EnableHA, "enable-ha", false, "Adds support for running multiple replicas via leadership election")
 	cmd.PersistentFlags().BoolVar(&options.SyncAfterRestart, "sync-after-restart", false, "Sync add events after reloader restarts")
+	cmd.PersistentFlags().BoolVar(&options.EnablePProf, "enable-pprof", false, "Enable pprof for profiling")
+	cmd.PersistentFlags().StringVar(&options.PProfAddr, "pprof-addr", ":6060", "Address to start pprof server on. Default is :6060")
 }
 
 func GetNamespaceLabelSelector() (string, error) {

pkg/common/common.go

@@ -0,0 +1,274 @@
+package common
+
+import (
+	"context"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/sirupsen/logrus"
+	"github.com/stakater/Reloader/internal/pkg/constants"
+	"github.com/stakater/Reloader/internal/pkg/options"
+	"github.com/stakater/Reloader/internal/pkg/util"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+)
+
+type Map map[string]string
+
+type ReloadCheckResult struct {
+	ShouldReload bool
+	AutoReload   bool
+}
+
+// ReloaderOptions contains all configurable options for the Reloader controller.
+// These options control how Reloader behaves when watching for changes in ConfigMaps and Secrets.
+type ReloaderOptions struct {
+	// AutoReloadAll enables automatic reloading of all resources when their corresponding ConfigMaps/Secrets are updated
+	AutoReloadAll bool `json:"autoReloadAll"`
+	// ConfigmapUpdateOnChangeAnnotation is the annotation key used to detect changes in ConfigMaps specified by name
+	ConfigmapUpdateOnChangeAnnotation string `json:"configmapUpdateOnChangeAnnotation"`
+	// SecretUpdateOnChangeAnnotation is the annotation key used to detect changes in Secrets specified by name
+	SecretUpdateOnChangeAnnotation string `json:"secretUpdateOnChangeAnnotation"`
+	// ReloaderAutoAnnotation is the annotation key used to detect changes in any referenced ConfigMaps or Secrets
+	ReloaderAutoAnnotation string `json:"reloaderAutoAnnotation"`
+	// IgnoreResourceAnnotation is the annotation key used to ignore resources from being watched
+	IgnoreResourceAnnotation string `json:"ignoreResourceAnnotation"`
+	// ConfigmapReloaderAutoAnnotation is the annotation key used to detect changes in ConfigMaps only
+	ConfigmapReloaderAutoAnnotation string `json:"configmapReloaderAutoAnnotation"`
+	// SecretReloaderAutoAnnotation is the annotation key used to detect changes in Secrets only
+	SecretReloaderAutoAnnotation string `json:"secretReloaderAutoAnnotation"`
+	// ConfigmapExcludeReloaderAnnotation is the annotation key containing comma-separated list of ConfigMaps to exclude from watching
+	ConfigmapExcludeReloaderAnnotation string `json:"configmapExcludeReloaderAnnotation"`
+	// SecretExcludeReloaderAnnotation is the annotation key containing comma-separated list of Secrets to exclude from watching
+	SecretExcludeReloaderAnnotation string `json:"secretExcludeReloaderAnnotation"`
+	// AutoSearchAnnotation is the annotation key used to detect changes in ConfigMaps/Secrets tagged with SearchMatchAnnotation
+	AutoSearchAnnotation string `json:"autoSearchAnnotation"`
+	// SearchMatchAnnotation is the annotation key used to tag ConfigMaps/Secrets to be found by AutoSearchAnnotation
+	SearchMatchAnnotation string `json:"searchMatchAnnotation"`
+	// RolloutStrategyAnnotation is the annotation key used to define the rollout update strategy for workloads
+	RolloutStrategyAnnotation string `json:"rolloutStrategyAnnotation"`
+	// PauseDeploymentAnnotation is the annotation key used to define the time period to pause a deployment after
+	PauseDeploymentAnnotation string `json:"pauseDeploymentAnnotation"`
+	// PauseDeploymentTimeAnnotation is the annotation key used to indicate when a deployment was paused by Reloader
+	PauseDeploymentTimeAnnotation string `json:"pauseDeploymentTimeAnnotation"`
+
+	// LogFormat specifies the log format to use (json, or empty string for default text format)
+	LogFormat string `json:"logFormat"`
+	// LogLevel specifies the log level to use (trace, debug, info, warning, error, fatal, panic)
+	LogLevel string `json:"logLevel"`
+	// IsArgoRollouts indicates whether support for Argo Rollouts is enabled
+	IsArgoRollouts bool `json:"isArgoRollouts"`
+	// ReloadStrategy specifies the strategy used to trigger resource reloads (env-vars or annotations)
+	ReloadStrategy string `json:"reloadStrategy"`
+	// ReloadOnCreate indicates whether to trigger reloads when ConfigMaps/Secrets are created
+	ReloadOnCreate bool `json:"reloadOnCreate"`
+	// ReloadOnDelete indicates whether to trigger reloads when ConfigMaps/Secrets are deleted
+	ReloadOnDelete bool `json:"reloadOnDelete"`
+	// SyncAfterRestart indicates whether to sync add events after Reloader restarts (only works when ReloadOnCreate is true)
+	SyncAfterRestart bool `json:"syncAfterRestart"`
+	// EnableHA indicates whether High Availability mode is enabled with leader election
+	EnableHA bool `json:"enableHA"`
+	// WebhookUrl is the URL to send webhook notifications to instead of performing reloads
+	WebhookUrl string `json:"webhookUrl"`
+	// ResourcesToIgnore is a list of resource types to ignore (e.g., "configmaps" or "secrets")
+	ResourcesToIgnore []string `json:"resourcesToIgnore"`
+	// NamespaceSelectors is a list of label selectors to filter namespaces to watch
+	NamespaceSelectors []string `json:"namespaceSelectors"`
+	// ResourceSelectors is a list of label selectors to filter ConfigMaps and Secrets to watch
+	ResourceSelectors []string `json:"resourceSelectors"`
+	// NamespacesToIgnore is a list of namespace names to ignore when watching for changes
+	NamespacesToIgnore []string `json:"namespacesToIgnore"`
+	// EnablePProf enables pprof for profiling
+	EnablePProf bool `json:"enablePProf"`
+	// PProfAddr is the address to start pprof server on
+	PProfAddr string `json:"pprofAddr"`
+}
+
+var CommandLineOptions *ReloaderOptions
+
+func PublishMetaInfoConfigmap(clientset kubernetes.Interface) {
+	namespace := os.Getenv("RELOADER_NAMESPACE")
+	if namespace == "" {
+		logrus.Warn("RELOADER_NAMESPACE is not set, skipping meta info configmap creation")
+		return
+	}
+
+	metaInfo := &MetaInfo{
+		BuildInfo:       *NewBuildInfo(),
+		ReloaderOptions: *GetCommandLineOptions(),
+		DeploymentInfo: metav1.ObjectMeta{
+			Name:      os.Getenv("RELOADER_DEPLOYMENT_NAME"),
+			Namespace: namespace,
+		},
+	}
+
+	configMap := metaInfo.ToConfigMap()
+
+	if _, err := clientset.CoreV1().ConfigMaps(namespace).Get(context.Background(), configMap.Name, metav1.GetOptions{}); err == nil {
+		logrus.Info("Meta info configmap already exists, updating it")
+		_, err = clientset.CoreV1().ConfigMaps(namespace).Update(context.Background(), configMap, metav1.UpdateOptions{})
+		if err != nil {
+			logrus.Warn("Failed to update existing meta info configmap: ", err)
+		}
+		return
+	}
+
+	_, err := clientset.CoreV1().ConfigMaps(namespace).Create(context.Background(), configMap, metav1.CreateOptions{})
+	if err != nil {
+		logrus.Warn("Failed to create meta info configmap: ", err)
+	}
+}
+
+func ShouldReload(config util.Config, resourceType string, annotations Map, podAnnotations Map, options *ReloaderOptions) ReloadCheckResult {
+
+	if resourceType == "Rollout" && !options.IsArgoRollouts {
+		return ReloadCheckResult{
+			ShouldReload: false,
+		}
+	}
+
+	ignoreResourceAnnotatonValue := config.ResourceAnnotations[options.IgnoreResourceAnnotation]
+	if ignoreResourceAnnotatonValue == "true" {
+		return ReloadCheckResult{
+			ShouldReload: false,
+		}
+	}
+
+	annotationValue, found := annotations[config.Annotation]
+	searchAnnotationValue, foundSearchAnn := annotations[options.AutoSearchAnnotation]
+	reloaderEnabledValue, foundAuto := annotations[options.ReloaderAutoAnnotation]
+	typedAutoAnnotationEnabledValue, foundTypedAuto := annotations[config.TypedAutoAnnotation]
+	excludeConfigmapAnnotationValue, foundExcludeConfigmap := annotations[options.ConfigmapExcludeReloaderAnnotation]
+	excludeSecretAnnotationValue, foundExcludeSecret := annotations[options.SecretExcludeReloaderAnnotation]
+
+	if !found && !foundAuto && !foundTypedAuto && !foundSearchAnn {
+		annotations = podAnnotations
+		annotationValue = annotations[config.Annotation]
+		searchAnnotationValue = annotations[options.AutoSearchAnnotation]
+		reloaderEnabledValue = annotations[options.ReloaderAutoAnnotation]
+		typedAutoAnnotationEnabledValue = annotations[config.TypedAutoAnnotation]
+	}
+
+	isResourceExcluded := false
+
+	switch config.Type {
+	case constants.ConfigmapEnvVarPostfix:
+		if foundExcludeConfigmap {
+			isResourceExcluded = checkIfResourceIsExcluded(config.ResourceName, excludeConfigmapAnnotationValue)
+		}
+	case constants.SecretEnvVarPostfix:
+		if foundExcludeSecret {
+			isResourceExcluded = checkIfResourceIsExcluded(config.ResourceName, excludeSecretAnnotationValue)
+		}
+	}
+
+	if isResourceExcluded {
+		return ReloadCheckResult{
+			ShouldReload: false,
+		}
+	}
+
+	reloaderEnabled, _ := strconv.ParseBool(reloaderEnabledValue)
+	typedAutoAnnotationEnabled, _ := strconv.ParseBool(typedAutoAnnotationEnabledValue)
+	if reloaderEnabled || typedAutoAnnotationEnabled || reloaderEnabledValue == "" && typedAutoAnnotationEnabledValue == "" && options.AutoReloadAll {
+		return ReloadCheckResult{
+			ShouldReload: true,
+			AutoReload:   true,
+		}
+	}
+
+	values := strings.Split(annotationValue, ",")
+	for _, value := range values {
+		value = strings.TrimSpace(value)
+		re := regexp.MustCompile("^" + value + "$")
+		if re.Match([]byte(config.ResourceName)) {
+			return ReloadCheckResult{
+				ShouldReload: true,
+				AutoReload:   false,
+			}
+		}
+	}
+
+	if searchAnnotationValue == "true" {
+		matchAnnotationValue := config.ResourceAnnotations[options.SearchMatchAnnotation]
+		if matchAnnotationValue == "true" {
+			return ReloadCheckResult{
+				ShouldReload: true,
+				AutoReload:   true,
+			}
+		}
+	}
+
+	return ReloadCheckResult{
+		ShouldReload: false,
+	}
+}
+
+func checkIfResourceIsExcluded(resourceName, excludedResources string) bool {
+	if excludedResources == "" {
+		return false
+	}
+
+	excludedResourcesList := strings.Split(excludedResources, ",")
+	for _, excludedResource := range excludedResourcesList {
+		if strings.TrimSpace(excludedResource) == resourceName {
+			return true
+		}
+	}
+
+	return false
+}
+
+func init() {
+	GetCommandLineOptions()
+}
+
+func GetCommandLineOptions() *ReloaderOptions {
+	if CommandLineOptions == nil {
+		CommandLineOptions = &ReloaderOptions{}
+	}
+
+	CommandLineOptions.AutoReloadAll = options.AutoReloadAll
+	CommandLineOptions.ConfigmapUpdateOnChangeAnnotation = options.ConfigmapUpdateOnChangeAnnotation
+	CommandLineOptions.SecretUpdateOnChangeAnnotation = options.SecretUpdateOnChangeAnnotation
+	CommandLineOptions.ReloaderAutoAnnotation = options.ReloaderAutoAnnotation
+	CommandLineOptions.IgnoreResourceAnnotation = options.IgnoreResourceAnnotation
+	CommandLineOptions.ConfigmapReloaderAutoAnnotation = options.ConfigmapReloaderAutoAnnotation
+	CommandLineOptions.SecretReloaderAutoAnnotation = options.SecretReloaderAutoAnnotation
+	CommandLineOptions.ConfigmapExcludeReloaderAnnotation = options.ConfigmapExcludeReloaderAnnotation
+	CommandLineOptions.SecretExcludeReloaderAnnotation = options.SecretExcludeReloaderAnnotation
+	CommandLineOptions.AutoSearchAnnotation = options.AutoSearchAnnotation
+	CommandLineOptions.SearchMatchAnnotation = options.SearchMatchAnnotation
+	CommandLineOptions.RolloutStrategyAnnotation = options.RolloutStrategyAnnotation
+	CommandLineOptions.PauseDeploymentAnnotation = options.PauseDeploymentAnnotation
+	CommandLineOptions.PauseDeploymentTimeAnnotation = options.PauseDeploymentTimeAnnotation
+	CommandLineOptions.LogFormat = options.LogFormat
+	CommandLineOptions.LogLevel = options.LogLevel
+	CommandLineOptions.ReloadStrategy = options.ReloadStrategy
+	CommandLineOptions.SyncAfterRestart = options.SyncAfterRestart
+	CommandLineOptions.EnableHA = options.EnableHA
+	CommandLineOptions.WebhookUrl = options.WebhookUrl
+	CommandLineOptions.ResourcesToIgnore = options.ResourcesToIgnore
+	CommandLineOptions.NamespaceSelectors = options.NamespaceSelectors
+	CommandLineOptions.ResourceSelectors = options.ResourceSelectors
+	CommandLineOptions.NamespacesToIgnore = options.NamespacesToIgnore
+	CommandLineOptions.IsArgoRollouts = parseBool(options.IsArgoRollouts)
+	CommandLineOptions.ReloadOnCreate = parseBool(options.ReloadOnCreate)
+	CommandLineOptions.ReloadOnDelete = parseBool(options.ReloadOnDelete)
+	CommandLineOptions.EnablePProf = options.EnablePProf
+
+	return CommandLineOptions
+}
+
+func parseBool(value string) bool {
+	if value == "" {
+		return false
+	}
+	result, err := strconv.ParseBool(value)
+	if err != nil {
+		return false // Default to false if parsing fails
+	}
+	return result
+}

pkg/common/metainfo.go

@@ -0,0 +1,129 @@
+package common
+
+import (
+	"encoding/json"
+	"fmt"
+	"runtime"
+	"time"
+
+	v1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// Version, Commit, and BuildDate are set during the build process
+// using the -X linker flag to inject these values into the binary.
+// They provide metadata about the build version, commit hash, build date, and whether there are
+// uncommitted changes in the source code at the time of build.
+// This information is useful for debugging and tracking the specific build of the Reloader binary.
+var Version = "dev"
+var Commit = "unknown"
+var BuildDate = "unknown"
+
+const (
+	MetaInfoConfigmapName       = "reloader-meta-info"
+	MetaInfoConfigmapLabelKey   = "reloader.stakater.com/meta-info"
+	MetaInfoConfigmapLabelValue = "reloader-oss"
+)
+
+// MetaInfo contains comprehensive metadata about the Reloader instance.
+// This includes build information, configuration options, and deployment details.
+type MetaInfo struct {
+	// BuildInfo contains information about the build version, commit, and compilation details
+	BuildInfo BuildInfo `json:"buildInfo"`
+	// ReloaderOptions contains all the configuration options and flags used by this Reloader instance
+	ReloaderOptions ReloaderOptions `json:"reloaderOptions"`
+	// DeploymentInfo contains metadata about the Kubernetes deployment of this Reloader instance
+	DeploymentInfo metav1.ObjectMeta `json:"deploymentInfo"`
+}
+
+// BuildInfo contains information about the build and version of the Reloader binary.
+// This includes Go version, release version, commit details, and build timestamp.
+type BuildInfo struct {
+	// GoVersion is the version of Go used to compile the binary
+	GoVersion string `json:"goVersion"`
+	// ReleaseVersion is the version tag or branch of the Reloader release
+	ReleaseVersion string `json:"releaseVersion"`
+	// CommitHash is the Git commit hash of the source code used to build this binary
+	CommitHash string `json:"commitHash"`
+	// CommitTime is the timestamp of the Git commit used to build this binary
+	CommitTime time.Time `json:"commitTime"`
+}
+
+func NewBuildInfo() *BuildInfo {
+	metaInfo := &BuildInfo{
+		GoVersion:      runtime.Version(),
+		ReleaseVersion: Version,
+		CommitHash:     Commit,
+		CommitTime:     ParseUTCTime(BuildDate),
+	}
+
+	return metaInfo
+}
+
+func (m *MetaInfo) ToConfigMap() *v1.ConfigMap {
+	return &v1.ConfigMap{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      MetaInfoConfigmapName,
+			Namespace: m.DeploymentInfo.Namespace,
+			Labels: map[string]string{
+				MetaInfoConfigmapLabelKey: MetaInfoConfigmapLabelValue,
+			},
+		},
+		Data: map[string]string{
+			"buildInfo":       toJson(m.BuildInfo),
+			"reloaderOptions": toJson(m.ReloaderOptions),
+			"deploymentInfo":  toJson(m.DeploymentInfo),
+		},
+	}
+}
+
+func NewMetaInfo(configmap *v1.ConfigMap) (*MetaInfo, error) {
+	var buildInfo BuildInfo
+	if val, ok := configmap.Data["buildInfo"]; ok {
+		err := json.Unmarshal([]byte(val), &buildInfo)
+		if err != nil {
+			return nil, fmt.Errorf("failed to unmarshal buildInfo: %w", err)
+		}
+	}
+
+	var reloaderOptions ReloaderOptions
+	if val, ok := configmap.Data["reloaderOptions"]; ok {
+		err := json.Unmarshal([]byte(val), &reloaderOptions)
+		if err != nil {
+			return nil, fmt.Errorf("failed to unmarshal reloaderOptions: %w", err)
+		}
+	}
+
+	var deploymentInfo metav1.ObjectMeta
+	if val, ok := configmap.Data["deploymentInfo"]; ok {
+		err := json.Unmarshal([]byte(val), &deploymentInfo)
+		if err != nil {
+			return nil, fmt.Errorf("failed to unmarshal deploymentInfo: %w", err)
+		}
+	}
+
+	return &MetaInfo{
+		BuildInfo:       buildInfo,
+		ReloaderOptions: reloaderOptions,
+		DeploymentInfo:  deploymentInfo,
+	}, nil
+}
+
+func toJson(data interface{}) string {
+	jsonData, err := json.Marshal(data)
+	if err != nil {
+		return ""
+	}
+	return string(jsonData)
+}
+
+func ParseUTCTime(value string) time.Time {
+	if value == "" {
+		return time.Time{} // Return zero time if value is empty
+	}
+	t, err := time.Parse(time.RFC3339, value)
+	if err != nil {
+		return time.Time{} // Return zero time if parsing fails
+	}
+	return t
+}

pkg/metainfo/metainfo.go

@@ -1,234 +0,0 @@
-package metainfo
-
-import (
-	"encoding/json"
-	"fmt"
-	"runtime"
-	"strconv"
-	"time"
-
-	"github.com/stakater/Reloader/internal/pkg/options"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-// Version, Commit, and BuildDate are set during the build process
-// using the -X linker flag to inject these values into the binary.
-// They provide metadata about the build version, commit hash, build date, and whether there are
-// uncommitted changes in the source code at the time of build.
-// This information is useful for debugging and tracking the specific build of the Reloader binary.
-var Version = "dev"
-var Commit = "unknown"
-var BuildDate = "unknown"
-
-const (
-	MetaInfoConfigmapName       = "reloader-meta-info"
-	MetaInfoConfigmapLabelKey   = "reloader.stakater.com/meta-info"
-	MetaInfoConfigmapLabelValue = "reloader-oss"
-)
-
-// ReloaderOptions contains all configurable options for the Reloader controller.
-// These options control how Reloader behaves when watching for changes in ConfigMaps and Secrets.
-type ReloaderOptions struct {
-	// AutoReloadAll enables automatic reloading of all resources when their corresponding ConfigMaps/Secrets are updated
-	AutoReloadAll bool `json:"autoReloadAll"`
-	// ConfigmapUpdateOnChangeAnnotation is the annotation key used to detect changes in ConfigMaps specified by name
-	ConfigmapUpdateOnChangeAnnotation string `json:"configmapUpdateOnChangeAnnotation"`
-	// SecretUpdateOnChangeAnnotation is the annotation key used to detect changes in Secrets specified by name
-	SecretUpdateOnChangeAnnotation string `json:"secretUpdateOnChangeAnnotation"`
-	// ReloaderAutoAnnotation is the annotation key used to detect changes in any referenced ConfigMaps or Secrets
-	ReloaderAutoAnnotation string `json:"reloaderAutoAnnotation"`
-	// IgnoreResourceAnnotation is the annotation key used to ignore resources from being watched
-	IgnoreResourceAnnotation string `json:"ignoreResourceAnnotation"`
-	// ConfigmapReloaderAutoAnnotation is the annotation key used to detect changes in ConfigMaps only
-	ConfigmapReloaderAutoAnnotation string `json:"configmapReloaderAutoAnnotation"`
-	// SecretReloaderAutoAnnotation is the annotation key used to detect changes in Secrets only
-	SecretReloaderAutoAnnotation string `json:"secretReloaderAutoAnnotation"`
-	// ConfigmapExcludeReloaderAnnotation is the annotation key containing comma-separated list of ConfigMaps to exclude from watching
-	ConfigmapExcludeReloaderAnnotation string `json:"configmapExcludeReloaderAnnotation"`
-	// SecretExcludeReloaderAnnotation is the annotation key containing comma-separated list of Secrets to exclude from watching
-	SecretExcludeReloaderAnnotation string `json:"secretExcludeReloaderAnnotation"`
-	// AutoSearchAnnotation is the annotation key used to detect changes in ConfigMaps/Secrets tagged with SearchMatchAnnotation
-	AutoSearchAnnotation string `json:"autoSearchAnnotation"`
-	// SearchMatchAnnotation is the annotation key used to tag ConfigMaps/Secrets to be found by AutoSearchAnnotation
-	SearchMatchAnnotation string `json:"searchMatchAnnotation"`
-	// RolloutStrategyAnnotation is the annotation key used to define the rollout update strategy for workloads
-	RolloutStrategyAnnotation string `json:"rolloutStrategyAnnotation"`
-	// PauseDeploymentAnnotation is the annotation key used to define the time period to pause a deployment after
-	PauseDeploymentAnnotation string `json:"pauseDeploymentAnnotation"`
-	// PauseDeploymentTimeAnnotation is the annotation key used to indicate when a deployment was paused by Reloader
-	PauseDeploymentTimeAnnotation string `json:"pauseDeploymentTimeAnnotation"`
-
-	// LogFormat specifies the log format to use (json, or empty string for default text format)
-	LogFormat string `json:"logFormat"`
-	// LogLevel specifies the log level to use (trace, debug, info, warning, error, fatal, panic)
-	LogLevel string `json:"logLevel"`
-	// IsArgoRollouts indicates whether support for Argo Rollouts is enabled
-	IsArgoRollouts bool `json:"isArgoRollouts"`
-	// ReloadStrategy specifies the strategy used to trigger resource reloads (env-vars or annotations)
-	ReloadStrategy string `json:"reloadStrategy"`
-	// ReloadOnCreate indicates whether to trigger reloads when ConfigMaps/Secrets are created
-	ReloadOnCreate bool `json:"reloadOnCreate"`
-	// ReloadOnDelete indicates whether to trigger reloads when ConfigMaps/Secrets are deleted
-	ReloadOnDelete bool `json:"reloadOnDelete"`
-	// SyncAfterRestart indicates whether to sync add events after Reloader restarts (only works when ReloadOnCreate is true)
-	SyncAfterRestart bool `json:"syncAfterRestart"`
-	// EnableHA indicates whether High Availability mode is enabled with leader election
-	EnableHA bool `json:"enableHA"`
-	// WebhookUrl is the URL to send webhook notifications to instead of performing reloads
-	WebhookUrl string `json:"webhookUrl"`
-	// ResourcesToIgnore is a list of resource types to ignore (e.g., "configmaps" or "secrets")
-	ResourcesToIgnore []string `json:"resourcesToIgnore"`
-	// NamespaceSelectors is a list of label selectors to filter namespaces to watch
-	NamespaceSelectors []string `json:"namespaceSelectors"`
-	// ResourceSelectors is a list of label selectors to filter ConfigMaps and Secrets to watch
-	ResourceSelectors []string `json:"resourceSelectors"`
-	// NamespacesToIgnore is a list of namespace names to ignore when watching for changes
-	NamespacesToIgnore []string `json:"namespacesToIgnore"`
-}
-
-// MetaInfo contains comprehensive metadata about the Reloader instance.
-// This includes build information, configuration options, and deployment details.
-type MetaInfo struct {
-	// BuildInfo contains information about the build version, commit, and compilation details
-	BuildInfo BuildInfo `json:"buildInfo"`
-	// ReloaderOptions contains all the configuration options and flags used by this Reloader instance
-	ReloaderOptions ReloaderOptions `json:"reloaderOptions"`
-	// DeploymentInfo contains metadata about the Kubernetes deployment of this Reloader instance
-	DeploymentInfo metav1.ObjectMeta `json:"deploymentInfo"`
-}
-
-func GetReloaderOptions() *ReloaderOptions {
-	return &ReloaderOptions{
-		AutoReloadAll:                      options.AutoReloadAll,
-		ConfigmapUpdateOnChangeAnnotation:  options.ConfigmapUpdateOnChangeAnnotation,
-		SecretUpdateOnChangeAnnotation:     options.SecretUpdateOnChangeAnnotation,
-		ReloaderAutoAnnotation:             options.ReloaderAutoAnnotation,
-		IgnoreResourceAnnotation:           options.IgnoreResourceAnnotation,
-		ConfigmapReloaderAutoAnnotation:    options.ConfigmapReloaderAutoAnnotation,
-		SecretReloaderAutoAnnotation:       options.SecretReloaderAutoAnnotation,
-		ConfigmapExcludeReloaderAnnotation: options.ConfigmapExcludeReloaderAnnotation,
-		SecretExcludeReloaderAnnotation:    options.SecretExcludeReloaderAnnotation,
-		AutoSearchAnnotation:               options.AutoSearchAnnotation,
-		SearchMatchAnnotation:              options.SearchMatchAnnotation,
-		RolloutStrategyAnnotation:          options.RolloutStrategyAnnotation,
-		PauseDeploymentAnnotation:          options.PauseDeploymentAnnotation,
-		PauseDeploymentTimeAnnotation:      options.PauseDeploymentTimeAnnotation,
-		LogFormat:                          options.LogFormat,
-		LogLevel:                           options.LogLevel,
-		IsArgoRollouts:                     parseBool(options.IsArgoRollouts),
-		ReloadStrategy:                     options.ReloadStrategy,
-		ReloadOnCreate:                     parseBool(options.ReloadOnCreate),
-		ReloadOnDelete:                     parseBool(options.ReloadOnDelete),
-		SyncAfterRestart:                   options.SyncAfterRestart,
-		EnableHA:                           options.EnableHA,
-		WebhookUrl:                         options.WebhookUrl,
-		ResourcesToIgnore:                  options.ResourcesToIgnore,
-		NamespaceSelectors:                 options.NamespaceSelectors,
-		ResourceSelectors:                  options.ResourceSelectors,
-		NamespacesToIgnore:                 options.NamespacesToIgnore,
-	}
-}
-
-// BuildInfo contains information about the build and version of the Reloader binary.
-// This includes Go version, release version, commit details, and build timestamp.
-type BuildInfo struct {
-	// GoVersion is the version of Go used to compile the binary
-	GoVersion string `json:"goVersion"`
-	// ReleaseVersion is the version tag or branch of the Reloader release
-	ReleaseVersion string `json:"releaseVersion"`
-	// CommitHash is the Git commit hash of the source code used to build this binary
-	CommitHash string `json:"commitHash"`
-	// CommitTime is the timestamp of the Git commit used to build this binary
-	CommitTime time.Time `json:"commitTime"`
-}
-
-func NewBuildInfo() *BuildInfo {
-	metaInfo := &BuildInfo{
-		GoVersion:      runtime.Version(),
-		ReleaseVersion: Version,
-		CommitHash:     Commit,
-		CommitTime:     ParseUTCTime(BuildDate),
-	}
-
-	return metaInfo
-}
-
-func (m *MetaInfo) ToConfigMap() *v1.ConfigMap {
-	return &v1.ConfigMap{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      MetaInfoConfigmapName,
-			Namespace: m.DeploymentInfo.Namespace,
-			Labels: map[string]string{
-				MetaInfoConfigmapLabelKey: MetaInfoConfigmapLabelValue,
-			},
-		},
-		Data: map[string]string{
-			"buildInfo":       toJson(m.BuildInfo),
-			"reloaderOptions": toJson(m.ReloaderOptions),
-			"deploymentInfo":  toJson(m.DeploymentInfo),
-		},
-	}
-}
-
-func NewMetaInfo(configmap *v1.ConfigMap) (*MetaInfo, error) {
-	var buildInfo BuildInfo
-	if val, ok := configmap.Data["buildInfo"]; ok {
-		err := json.Unmarshal([]byte(val), &buildInfo)
-		if err != nil {
-			return nil, fmt.Errorf("failed to unmarshal buildInfo: %w", err)
-		}
-	}
-
-	var reloaderOptions ReloaderOptions
-	if val, ok := configmap.Data["reloaderOptions"]; ok {
-		err := json.Unmarshal([]byte(val), &reloaderOptions)
-		if err != nil {
-			return nil, fmt.Errorf("failed to unmarshal reloaderOptions: %w", err)
-		}
-	}
-
-	var deploymentInfo metav1.ObjectMeta
-	if val, ok := configmap.Data["deploymentInfo"]; ok {
-		err := json.Unmarshal([]byte(val), &deploymentInfo)
-		if err != nil {
-			return nil, fmt.Errorf("failed to unmarshal deploymentInfo: %w", err)
-		}
-	}
-
-	return &MetaInfo{
-		BuildInfo:       buildInfo,
-		ReloaderOptions: reloaderOptions,
-		DeploymentInfo:  deploymentInfo,
-	}, nil
-}
-
-func toJson(data interface{}) string {
-	jsonData, err := json.Marshal(data)
-	if err != nil {
-		return ""
-	}
-	return string(jsonData)
-}
-
-func parseBool(value string) bool {
-	if value == "" {
-		return false
-	}
-	result, err := strconv.ParseBool(value)
-	if err != nil {
-		return false // Default to false if parsing fails
-	}
-	return result
-}
-
-func ParseUTCTime(value string) time.Time {
-	if value == "" {
-		return time.Time{} // Return zero time if value is empty
-	}
-	t, err := time.Parse(time.RFC3339, value)
-	if err != nil {
-		return time.Time{} // Return zero time if parsing fails
-	}
-	return t
-}