From 4a0eb94aae25acc249a2dc37071e84d92890a2ef Mon Sep 17 00:00:00 2001
From: Sushant2504m <snadavad@redhat.com>
Date: Mon, 21 Sep 2026 12:18:26 +0530
Subject: [PATCH] feat: Remove monitoring command and fix command casing in
 README
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This commit addresses code review feedback by completely removing the
monitoring command instead of just deprecating it, as it no longer
supports active OpenShift ROSA versions.

Changes:
- Remove cmd/ocm-backplane/monitoring/ directory and command
- Remove pkg/monitoring/ package entirely
- Remove monitoring command registration from root.go
- Remove monitoring command from README usage table
- Remove "Monitoring" documentation section from README
- Fix command casing in README: managedJob → managedjob, testJob → testjob
- Remove non-existent managedjob list command from README

Rationale:
Following OpenShift 4.11+, monitoring stack UIs (Prometheus, AlertManager,
Grafana) are deprecated in favor of the console's Observe tab. Since the
monitoring command doesn't support active ROSA versions, complete removal
is cleaner than deprecation warnings.

Users should use: ocm backplane console → Observe tab

Addresses feedback from: @samanthajayasinghe, @coderabbitai

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
---
 README.md                                  |  28 +-
 cmd/ocm-backplane/monitoring/monitoring.go |  75 ----
 cmd/ocm-backplane/root.go                  |   2 -
 pkg/monitoring/monitoring.go               | 384 ---------------------
 pkg/monitoring/monitoring_suite_test.go    |  20 --
 pkg/monitoring/monitoring_test.go          | 230 ------------
 6 files changed, 8 insertions(+), 731 deletions(-)
 delete mode 100644 cmd/ocm-backplane/monitoring/monitoring.go
 delete mode 100644 pkg/monitoring/monitoring.go
 delete mode 100644 pkg/monitoring/monitoring_suite_test.go
 delete mode 100644 pkg/monitoring/monitoring_test.go

diff --git a/README.md b/README.md
index dd08933e..2572b145 100644
--- a/README.md
+++ b/README.md
@@ -80,20 +80,18 @@ To setup the PS1(prompt) for bash/zsh, please follow [these instructions](https:
 | `ocm backplane cloud credentials [flags]`                                   | Retrieve a set of temporary cloud credentials for the cluster's cloud provider           |
 | `ocm backplane cloud ssm --node <node-name>`                                | Start an aws ssm session for an HCP cluster                                              |
 | `ocm backplane elevate <reason> -- <command>`                               | Elevate privileges to backplane-cluster-admin and add a reason to the api request, this reason will be stored for 20min for future usage        |
-| `ocm backplane monitoring <prometheus/alertmanager/thanos/grafana> [flags]` | Launch the specified monitoring UI (Deprecated following v4.11 for cluster monitoring stack)|
 | `ocm backplane script describe <script> [flags]`                            | Describe the given backplane script                                                      |
 | `ocm backplane script list [flags]`                                         | List available backplane scripts |
 | `ocm backplane session [flags]`                                             | Create a new session and log into the cluster                                            |
 | `ocm backplane status`                                                      | Print essential cluster info                                                             |
-| `ocm backplane managedJob create <script> [flags]`                          | Create a backplane managed job resource                                                  |
-| `ocm backplane managedJob get <job_name> [flags]`                           | Retrieve a backplane managed job resource                                                |
-| `ocm backplane managedJob list [flags]`                                     | Retrieve a list of backplane managed job resources                                       |
-| `ocm backplane managedJob logs <job_name> [flags]`                          | Retrieve logs of the specified managed job resource                                      |
-| `ocm backplane managedJob delete <job_name> [flags]`                        | Delete the specified managed job resource                                                |
-| `ocm backplane testJob render [flags]`                                      | Render the Kubernetes YAML (ServiceAccount, RBAC and Pod) for a draft managed script locally, so it can be applied directly with `oc apply -f`. See [Testing a draft managed script](docs/testing-managed-scripts.md). |
-| `ocm backplane testJob create <script> [flags]`                             | (Deprecated, use `testJob render` instead) Create a backplane test managed job on a non-production cluster for testing.                   |
-| `ocm backplane testJob get <job_name> [flags]`                              | (Deprecated, use `testJob render` instead) Retrieve a backplane test job resource                                                        |
-| `ocm backplane testJob logs <job_name> [flags]`                             | (Deprecated, use `testJob render` instead) Retrieve logs of the specified test job resource                                              |
+| `ocm backplane managedjob create <script> [flags]`                          | Create a backplane managed job resource                                                  |
+| `ocm backplane managedjob get <job_name> [flags]`                           | Retrieve a backplane managed job resource                                                |
+| `ocm backplane managedjob logs <job_name> [flags]`                          | Retrieve logs of the specified managed job resource                                      |
+| `ocm backplane managedjob delete <job_name> [flags]`                        | Delete the specified managed job resource                                                |
+| `ocm backplane testjob render [flags]`                                      | Render the Kubernetes YAML (ServiceAccount, RBAC and Pod) for a draft managed script locally, so it can be applied directly with `oc apply -f`. See [Testing a draft managed script](docs/testing-managed-scripts.md). |
+| `ocm backplane testjob create <script> [flags]`                             | (Deprecated, use `testjob render` instead) Create a backplane test managed job on a non-production cluster for testing.                   |
+| `ocm backplane testjob get <job_name> [flags]`                              | (Deprecated, use `testjob render` instead) Retrieve a backplane test job resource                                                        |
+| `ocm backplane testjob logs <job_name> [flags]`                             | (Deprecated, use `testjob render` instead) Retrieve logs of the specified test job resource                                              |
 | `ocm backplane upgrade`                                                     | Upgrade backplane-cli to the latest version                                              |
 | `ocm backplane version`                                                     | Display the installed backplane-cli version                                              |
 | `ocm backplane healthcheck`                                                 | Check the VPN and Proxy connectivity on the host network when experiencing isssues accessing the backplane API|
@@ -284,16 +282,6 @@ sh-5.1$
 $ ocm backplane cloud ssm --node ip-xx-x-xxx-xxx.xxxxxx.compute.internal -- free -m
 ```
 
-## Monitoring
-Monitoring command can be used to launch the specified monitoring UI.
-
-Run this command from within a cluster :
-
-```
-ocm backplane monitoring <prometheus/alertmanager/thanos/grafana> [flags]
-```
-
->Note: Following version 4.11, Prometheus, AlertManager and Grafana monitoring UIs are deprecated for openshift-monitoring stack, please use 'ocm backplane console' and use the observe tab for the same. Other monitoring stacks remain unaffected.
 ## Backplane Session 
 Backplane session command will create an isolated environment to interact with a cluster in its own directory. 
 The default location for this is ~/backplane. 
diff --git a/cmd/ocm-backplane/monitoring/monitoring.go b/cmd/ocm-backplane/monitoring/monitoring.go
deleted file mode 100644
index cfb744c1..00000000
--- a/cmd/ocm-backplane/monitoring/monitoring.go
+++ /dev/null
@@ -1,75 +0,0 @@
-package monitoring
-
-import (
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/spf13/cobra"
-
-	"github.com/openshift/backplane-cli/pkg/monitoring"
-)
-
-var MonitoringCmd = &cobra.Command{
-	Use:          fmt.Sprintf("monitoring <%s>", strings.Join(monitoring.ValidMonitoringNames, "|")),
-	Short:        "Create a local proxy to the monitoring UI",
-	Long:         fmt.Sprintf(`It will proxy to the monitoring UI including %s.`, strings.Join(monitoring.ValidMonitoringNames, ",")),
-	Args:         cobra.MatchAll(cobra.MinimumNArgs(1), cobra.OnlyValidArgs),
-	ValidArgs:    monitoring.ValidMonitoringNames,
-	RunE:         runMonitoring,
-	SilenceUsage: true,
-}
-
-func init() {
-	flags := MonitoringCmd.Flags()
-	flags.BoolVarP(
-		&monitoring.MonitoringOpts.Browser,
-		"browser",
-		"b",
-		false,
-		"Open the browser automatically.",
-	)
-	flags.StringVarP(
-		&monitoring.MonitoringOpts.Namespace,
-		"namespace",
-		"n",
-		"openshift-monitoring",
-		"Specify namespace of monitoring stack.",
-	)
-	flags.StringVarP(
-		&monitoring.MonitoringOpts.Selector,
-		"selector",
-		"l",
-		"",
-		"Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2).",
-	)
-	flags.StringVarP(
-		&monitoring.MonitoringOpts.Port,
-		"port",
-		"p",
-		"",
-		"The port the remote application listens on. (Default will be picked by server based on application's conventional port.)",
-	)
-	flags.StringVarP(
-		&monitoring.MonitoringOpts.OriginURL,
-		"origin",
-		"u",
-		"",
-		"The original url. Eg, copied from the prometheus url in pagerduty. When specified, it will print the proxied url of the corresponding original url.",
-	)
-	flags.StringVar(
-		&monitoring.MonitoringOpts.ListenAddr,
-		"listen",
-		"",
-		"The local address to listen to. Recommend using 127.0.0.1:xxxx to minimize security risk. The default will pick a random port on 127.0.0.1",
-	)
-
-}
-
-// runMonitoring create local proxy url to serve monitoring dashboard
-func runMonitoring(cmd *cobra.Command, argv []string) error {
-	monitoringType := argv[0]
-	monitoring.MonitoringOpts.KeepAlive = true
-	client := monitoring.NewClient("", http.Client{})
-	return client.RunMonitoring(monitoringType)
-}
diff --git a/cmd/ocm-backplane/root.go b/cmd/ocm-backplane/root.go
index 7d338308..2df93c86 100644
--- a/cmd/ocm-backplane/root.go
+++ b/cmd/ocm-backplane/root.go
@@ -31,7 +31,6 @@ import (
 	"github.com/openshift/backplane-cli/cmd/ocm-backplane/login"
 	"github.com/openshift/backplane-cli/cmd/ocm-backplane/logout"
 	managedjob "github.com/openshift/backplane-cli/cmd/ocm-backplane/managedJob"
-	"github.com/openshift/backplane-cli/cmd/ocm-backplane/monitoring"
 	"github.com/openshift/backplane-cli/cmd/ocm-backplane/remediation"
 	"github.com/openshift/backplane-cli/cmd/ocm-backplane/script"
 	"github.com/openshift/backplane-cli/cmd/ocm-backplane/session"
@@ -81,7 +80,6 @@ func init() {
 	rootCmd.AddCommand(testjob.NewTestJobCommand())
 	rootCmd.AddCommand(upgrade.UpgradeCmd)
 	rootCmd.AddCommand(version.VersionCmd)
-	rootCmd.AddCommand(monitoring.MonitoringCmd)
 	rootCmd.AddCommand(healthcheck.HealthCheckCmd)
 	rootCmd.AddCommand(remediation.NewRemediationCmd())
 }
diff --git a/pkg/monitoring/monitoring.go b/pkg/monitoring/monitoring.go
deleted file mode 100644
index edd9d3de..00000000
--- a/pkg/monitoring/monitoring.go
+++ /dev/null
@@ -1,384 +0,0 @@
-package monitoring
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"log"
-	"net"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"strings"
-
-	"github.com/Masterminds/semver"
-	routev1typedclient "github.com/openshift/client-go/route/clientset/versioned/typed/route/v1"
-	userv1typedclient "github.com/openshift/client-go/user/clientset/versioned/typed/user/v1"
-	"github.com/pkg/browser"
-	logger "github.com/sirupsen/logrus"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/client-go/tools/clientcmd"
-
-	"github.com/openshift/backplane-cli/pkg/cli/config"
-	"github.com/openshift/backplane-cli/pkg/ocm"
-	"github.com/openshift/backplane-cli/pkg/utils"
-)
-
-const (
-	ALERTMANAGER          = "alertmanager"
-	PROMETHEUS            = "prometheus"
-	THANOS                = "thanos"
-	GRAFANA               = "grafana"
-	OpenShiftMonitoringNS = "openshift-monitoring"
-)
-
-var (
-	MonitoringOpts struct {
-		Namespace  string
-		Selector   string
-		Port       string
-		OriginURL  string
-		ListenAddr string
-		Browser    bool
-		KeepAlive  bool
-	}
-	ValidMonitoringNames = []string{PROMETHEUS, ALERTMANAGER, THANOS, GRAFANA}
-)
-
-type Client struct {
-	url  string
-	http http.Client
-}
-
-func NewClient(url string, http http.Client) Client {
-	return Client{url, http}
-}
-
-// RunMonitoring serve http proxy URL to monitoring dashboard
-func (c Client) RunMonitoring(monitoringType string) error {
-
-	// check empty monitoring name
-	if monitoringType == "" {
-		return fmt.Errorf("monitoring type is empty")
-	}
-
-	cfg, err := clientcmd.BuildConfigFromFlags("", clientcmd.NewDefaultPathOptions().GetDefaultFilename())
-	if err != nil {
-		return err
-	}
-
-	// creates URL for serving
-	if !strings.Contains(cfg.Host, "backplane/cluster") {
-		return fmt.Errorf("the api server is not a backplane url, please make sure you login to the cluster using backplane")
-	}
-
-	// set up monitoring Url if it's empty
-	if c.url == "" {
-		c.url, err = getBackplaneMonitoringURL(monitoringType)
-		if err != nil {
-			return err
-		}
-	}
-
-	mURL, err := url.Parse(c.url)
-	if err != nil {
-		return err
-	}
-	// creates OCM access token
-	accessToken, err := ocm.DefaultOCMInterface.GetOCMAccessToken()
-	if err != nil {
-		return err
-	}
-
-	// check for valid cluster versions
-	err = validateClusterVersion(monitoringType)
-	if err != nil {
-		return err
-	}
-
-	isGrafana := monitoringType == GRAFANA
-	hasNs := len(MonitoringOpts.Namespace) != 0
-	hasAppSelector := len(MonitoringOpts.Selector) != 0
-	hasPort := len(MonitoringOpts.Port) != 0
-	hasURL := len(MonitoringOpts.OriginURL) != 0
-
-	// serveURL is the port-forward url we print to the user in the end.
-	serveURL, err := serveURL(hasURL, hasNs, cfg)
-	if err != nil {
-		return err
-	}
-
-	var name string
-	if isGrafana {
-		userInterface, err := userv1typedclient.NewForConfig(cfg)
-		if err != nil {
-			return err
-		}
-
-		user, err := userInterface.Users().Get(context.TODO(), "~", metav1.GetOptions{})
-		if err != nil {
-			return err
-		}
-		name = strings.Replace(user.Name, "system:serviceaccount:", "", 1)
-	}
-
-	// Test if the monitoring stack works, by sending a request to backend/backplane-api
-	req, err := http.NewRequest("GET", "/", nil)
-	if err != nil {
-
-		log.Fatalf("connecting to server %v", err)
-	}
-
-	// Add http proxy transport
-	proxyURL, err := getProxyURL()
-	if err != nil {
-		return err
-	}
-	if proxyURL != nil {
-		proxyURL, err := url.Parse(*proxyURL)
-		if err != nil {
-			return err
-		}
-		http.DefaultTransport = &http.Transport{
-			Proxy: http.ProxyURL(proxyURL),
-		}
-
-		logger.Debugf("Using backplane Proxy URL: %s\n", proxyURL)
-	}
-
-	req = setProxyRequest(req, mURL, name, accessToken, isGrafana, hasNs, hasAppSelector, hasPort)
-
-	resp, err := c.http.Do(req)
-	if err != nil {
-		log.Fatalln(err)
-	}
-
-	defer func() { _ = resp.Body.Close() }()
-
-	if resp.StatusCode >= 400 {
-		responseBody, _ := io.ReadAll(resp.Body)
-		return fmt.Errorf("%s", string(responseBody))
-	}
-
-	// If the above test pass, we will construct a reverse proxy for the user
-	proxy := &httputil.ReverseProxy{
-		Director: func(req *http.Request) {
-			setProxyRequest(req, mURL, name, accessToken, isGrafana, hasNs, hasAppSelector, hasPort)
-		},
-	}
-
-	// serve the proxy
-	var addr string
-	if len(MonitoringOpts.ListenAddr) > 0 {
-		// net.Listen will validate the addr later
-		addr = MonitoringOpts.ListenAddr
-	} else {
-		port, err := utils.GetFreePort()
-		if err != nil {
-			return err
-		}
-		addr = fmt.Sprintf("127.0.0.1:%d", port)
-	}
-
-	l, err := net.Listen("tcp", addr)
-	if err != nil {
-		return err
-	}
-
-	serveURL.Host = addr
-
-	if MonitoringOpts.Browser {
-		err = browser.OpenURL(serveURL.String())
-		if err != nil {
-			logger.Warnf("failed opening a browser: %s", err)
-		}
-	}
-
-	if MonitoringOpts.KeepAlive {
-		if !MonitoringOpts.Browser {
-			fmt.Printf("Serving %s at %s\n", monitoringType, serveURL.String())
-		}
-		return http.Serve(l, proxy) //#nosec: G114
-	} else {
-		return nil
-	}
-
-}
-
-// getBackplaneMonitoringURL returns the backplane API monitoring URL based on monitoring type
-func getBackplaneMonitoringURL(monitoringType string) (string, error) {
-	monitoringURL := ""
-	cfg, err := clientcmd.BuildConfigFromFlags("", clientcmd.NewDefaultPathOptions().GetDefaultFilename())
-	if err != nil {
-		return monitoringURL, err
-	}
-
-	// creates URL for serving
-	if !strings.Contains(cfg.Host, "backplane/cluster") {
-		return monitoringURL, fmt.Errorf("the api server is not a backplane url, please make sure you login to the cluster using backplane")
-	}
-	monitoringURL = strings.Replace(cfg.Host, "backplane/cluster", fmt.Sprintf("backplane/%s", monitoringType), 1)
-	monitoringURL = strings.TrimSuffix(monitoringURL, "/")
-	return monitoringURL, nil
-}
-
-// Setting Headers, accessToken, port and selector
-func setProxyRequest(
-	req *http.Request,
-	proxyURL *url.URL,
-	userName string,
-	accessToken *string,
-	isGrafana bool,
-	hasNs bool,
-	hasAppSelector bool,
-	hasPort bool,
-) *http.Request {
-	req.URL.Scheme = "https"
-	req.Host = proxyURL.Host
-	req.URL.Host = proxyURL.Host
-	req.URL.Path = singleJoiningSlash(proxyURL.Path, req.URL.Path)
-	if _, ok := req.Header["User-Agent"]; !ok {
-		// explicitly disable User-Agent so it's not set to default value
-		req.Header.Set("User-Agent", "")
-	}
-	if isGrafana {
-		req.Header.Set("x-forwarded-user", userName)
-	}
-	if hasNs {
-		req.Header.Set("x-namespace", MonitoringOpts.Namespace)
-	}
-	if hasAppSelector {
-		req.Header.Set("x-selector", MonitoringOpts.Selector)
-	}
-	if hasPort {
-		req.Header.Set("x-port", MonitoringOpts.Port)
-	}
-	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *accessToken))
-
-	return req
-}
-
-// singleJoiningSlash return format the url slash
-func singleJoiningSlash(a, b string) string {
-	aSlash := strings.HasSuffix(a, "/")
-	bSlash := strings.HasPrefix(b, "/")
-	switch {
-	case aSlash && bSlash:
-		return a + b[1:]
-	case !aSlash && !bSlash:
-		return a + "/" + b
-	}
-	return a + b
-}
-
-// Check if a route of the originURL exist in the namespace.
-func hasMatchRoute(namespace string, originURL *url.URL, cfg *restclient.Config) bool {
-	routeInterface, err := routev1typedclient.NewForConfig(cfg)
-	if err != nil {
-		logger.Warnf("cannot create route client-go interface %s", err)
-		return false
-	}
-	routes, err := routeInterface.Routes(namespace).List(context.TODO(), metav1.ListOptions{})
-	if err != nil {
-		logger.Warnf("cannot get routes: %s", err)
-		return false
-	}
-	for _, rt := range routes.Items {
-		ri := rt.Status.Ingress
-		for _, ig := range ri {
-			logger.Debugf("found route ingress %s", ig.Host)
-			if utils.MatchBaseDomain(originURL.Hostname(), ig.Host) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// serveURL returns the port-forward url to the route
-func serveURL(hasURL, hasNs bool, cfg *restclient.Config) (*url.URL, error) {
-	serveURL := &url.URL{
-		Scheme: "http",
-	}
-
-	if hasURL {
-		originURL, err := url.Parse(MonitoringOpts.OriginURL)
-		if err != nil {
-			return nil, err
-		}
-		// verify if the provided url matches the current login cluster
-		currentClusterInfo, err := utils.DefaultClusterUtils.GetBackplaneClusterFromConfig()
-		if err != nil {
-			return nil, err
-		}
-		currentCluster, err := ocm.DefaultOCMInterface.GetClusterInfoByID(currentClusterInfo.ClusterID)
-		if err != nil {
-			return nil, err
-		}
-		baseDomain := currentCluster.DNS().BaseDomain()
-		if !utils.MatchBaseDomain(originURL.Hostname(), baseDomain) {
-			return nil, fmt.Errorf("the basedomain %s of the current logged cluster %s does not match the provided url, please login to the corresponding cluster first",
-				baseDomain, currentClusterInfo.ClusterID)
-		}
-		// verify if the route exists in the given namespace
-		if !hasNs {
-			// namespace has a default value, prompt error in case user specify it with blank string.
-			return nil, fmt.Errorf("namepace should not be blank, please specify namespace by --namespace")
-		}
-
-		if !hasMatchRoute(MonitoringOpts.Namespace, originURL, cfg) {
-			return nil, fmt.Errorf("cannot find a matching route in namespace %s for the given url, please specify a correct namespace by --namespace",
-				MonitoringOpts.Namespace)
-		}
-
-		// append path and query to the url printed later
-		serveURL.Path = originURL.Path
-		serveURL.RawQuery = originURL.RawQuery
-		serveURL.Fragment = originURL.Fragment
-		return serveURL, nil
-	}
-
-	return serveURL, nil
-}
-
-// getProxyURL returns the proxy url
-func getProxyURL() (proxyURL *string, err error) {
-	bpConfig, err := config.GetBackplaneConfiguration()
-	if err != nil {
-		return nil, err
-	}
-
-	return bpConfig.ProxyURL, nil
-}
-
-// validateClusterVersion checks the clusterversion based on namespace
-func validateClusterVersion(monitoringName string) error {
-	if MonitoringOpts.Namespace == OpenShiftMonitoringNS {
-		//checks cluster version
-		currentClusterInfo, err := utils.DefaultClusterUtils.GetBackplaneClusterFromConfig()
-		if err != nil {
-			return err
-		}
-
-		currentCluster, err := ocm.DefaultOCMInterface.GetClusterInfoByID(currentClusterInfo.ClusterID)
-		if err != nil {
-			return err
-		}
-
-		clusterVersion := currentCluster.OpenshiftVersion()
-		if clusterVersion != "" {
-			version, err := semver.NewVersion(clusterVersion)
-			if err != nil {
-				return err
-			}
-			if version.Minor() >= 11 && (monitoringName == PROMETHEUS || monitoringName == ALERTMANAGER || monitoringName == GRAFANA) {
-				return fmt.Errorf("this cluster's version is 4.11 or greater. " +
-					"Following version 4.11, Prometheus, AlertManager and Grafana monitoring UIs are deprecated, " +
-					"please use 'ocm backplane console' and use the observe tab for the same",
-				)
-			}
-		}
-	}
-	return nil
-}
diff --git a/pkg/monitoring/monitoring_suite_test.go b/pkg/monitoring/monitoring_suite_test.go
deleted file mode 100644
index 36870807..00000000
--- a/pkg/monitoring/monitoring_suite_test.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package monitoring
-
-import (
-	"io"
-	"strings"
-	"testing"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-func TestIt(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Monitoring Test Suite")
-}
-
-func MakeIoReader(s string) io.ReadCloser {
-	r := io.NopCloser(strings.NewReader(s))
-	return r
-}
diff --git a/pkg/monitoring/monitoring_test.go b/pkg/monitoring/monitoring_test.go
deleted file mode 100644
index 06f62da2..00000000
--- a/pkg/monitoring/monitoring_test.go
+++ /dev/null
@@ -1,230 +0,0 @@
-package monitoring
-
-import (
-	"net/http"
-	"os"
-
-	"net/http/httptest"
-
-	"go.uber.org/mock/gomock"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-	cmv1 "github.com/openshift-online/ocm-sdk-go/clustersmgmt/v1"
-	"k8s.io/client-go/tools/clientcmd/api"
-
-	"github.com/openshift/backplane-cli/pkg/backplaneapi"
-	backplaneapiMock "github.com/openshift/backplane-cli/pkg/backplaneapi/mocks"
-	"github.com/openshift/backplane-cli/pkg/client/mocks"
-	"github.com/openshift/backplane-cli/pkg/info"
-	"github.com/openshift/backplane-cli/pkg/ocm"
-	ocmMock "github.com/openshift/backplane-cli/pkg/ocm/mocks"
-	"github.com/openshift/backplane-cli/pkg/utils"
-)
-
-var _ = Describe("Backplane Monitoring Unit test", func() {
-	var (
-		mockCtrl           *gomock.Controller
-		mockClient         *mocks.MockClientInterface
-		mockClientWithResp *mocks.MockClientWithResponsesInterface
-		mockOcmInterface   *ocmMock.MockOCMInterface
-		mockClientUtil     *backplaneapiMock.MockClientUtils
-
-		testClusterID   string
-		testToken       string
-		trueClusterID   string
-		backplaneAPIUri string
-
-		fakeResp *http.Response
-
-		testKubeCfg       api.Config
-		clusterVersion412 *cmv1.Cluster
-		clusterVersion410 *cmv1.Cluster
-		client            Client
-		ocmEnv            *cmv1.Environment
-	)
-
-	BeforeEach(func() {
-		mockCtrl = gomock.NewController(GinkgoT())
-		mockClient = mocks.NewMockClientInterface(mockCtrl)
-		mockClientWithResp = mocks.NewMockClientWithResponsesInterface(mockCtrl)
-
-		mockOcmInterface = ocmMock.NewMockOCMInterface(mockCtrl)
-		ocm.DefaultOCMInterface = mockOcmInterface
-
-		mockClientUtil = backplaneapiMock.NewMockClientUtils(mockCtrl)
-		backplaneapi.DefaultClientUtils = mockClientUtil
-
-		testClusterID = "test123"
-		testToken = "hello123"
-		trueClusterID = "trueID123"
-		backplaneAPIUri = "https://api.integration.backplane.example.com"
-
-		fakeResp = &http.Response{
-			Body:       MakeIoReader(`{"proxy_uri":"proxy", "statusCode":200, "message":"msg"}`),
-			Header:     map[string][]string{},
-			StatusCode: http.StatusOK,
-		}
-		fakeResp.Header.Add("Content-Type", "json")
-
-		clusterVersion412, _ = cmv1.NewCluster().
-			OpenshiftVersion("4.12.0").
-			CloudProvider(cmv1.NewCloudProvider().ID("aws")).
-			Product(cmv1.NewProduct().ID("dedicated")).
-			AdditionalTrustBundle("REDACTED").
-			Proxy(cmv1.NewProxy().HTTPProxy("http://my.proxy:80").HTTPSProxy("https://my.proxy:443")).Build()
-
-		clusterVersion410, _ = cmv1.NewCluster().
-			OpenshiftVersion("4.10.0").
-			CloudProvider(cmv1.NewCloudProvider().ID("aws")).
-			Product(cmv1.NewProduct().ID("dedicated")).
-			AdditionalTrustBundle("REDACTED").
-			Proxy(cmv1.NewProxy().HTTPProxy("http://my.proxy:80").HTTPSProxy("https://my.proxy:443")).Build()
-
-		testKubeCfg = api.Config{
-			Kind:        "Config",
-			APIVersion:  "v1",
-			Preferences: api.Preferences{},
-			Clusters: map[string]*api.Cluster{
-				"testcluster": {
-					Server: "https://api-backplane.apps.something.com/backplane/cluster/test123",
-				},
-				"api-backplane.apps.something.com:443": { // Remark that the cluster name does not match the cluster ID in below URL
-					Server: "https://api-backplane.apps.something.com/backplane/cluster/test123",
-				},
-			},
-			AuthInfos: map[string]*api.AuthInfo{
-				"testauth": {
-					Token: "token123",
-				},
-			},
-			Contexts: map[string]*api.Context{
-				"default/testcluster/testauth": {
-					Cluster:   "testcluster",
-					AuthInfo:  "testauth",
-					Namespace: "default",
-				},
-				"custom-context": {
-					Cluster:   "api-backplane.apps.something.com:443",
-					AuthInfo:  "testauth",
-					Namespace: "test-namespace",
-				},
-			},
-			CurrentContext: "default/testcluster/testauth",
-			Extensions:     nil,
-		}
-
-		err := utils.CreateTempKubeConfig(&testKubeCfg)
-		Expect(err).To(BeNil())
-
-		_ = os.Setenv(info.BackplaneURLEnvName, backplaneAPIUri)
-		ocmEnv, _ = cmv1.NewEnvironment().BackplaneURL("https://dummy.api").Build()
-	})
-
-	AfterEach(func() {
-		mockCtrl.Finish()
-	})
-
-	Context("check Backplane monitoring", func() {
-		It("should fail for empty monitoring name", func() {
-
-			client = NewClient("", client.http)
-			err := client.RunMonitoring("")
-
-			Expect(err).NotTo(BeNil())
-			Expect(err.Error()).Should(ContainSubstring("monitoring type is empty"))
-		})
-
-		It("should fail for cluster version greater than 4.11 and openshift monitoring namespace ", func() {
-
-			mockOcmInterface.EXPECT().GetOCMEnvironment().Return(ocmEnv, nil).AnyTimes()
-			mockClientWithResp.EXPECT().LoginClusterWithResponse(gomock.Any(), gomock.Any()).Return(nil, nil).AnyTimes()
-			mockOcmInterface.EXPECT().GetTargetCluster(trueClusterID).Return(trueClusterID, testClusterID, nil).AnyTimes()
-			mockOcmInterface.EXPECT().GetClusterInfoByID(testClusterID).Return(clusterVersion412, nil).AnyTimes()
-			mockOcmInterface.EXPECT().IsClusterHibernating(gomock.Eq(trueClusterID)).Return(false, nil).AnyTimes()
-			mockOcmInterface.EXPECT().GetOCMAccessToken().Return(&testToken, nil).AnyTimes()
-			mockClientUtil.EXPECT().MakeRawBackplaneAPIClientWithAccessToken(backplaneAPIUri, testToken).Return(mockClient, nil).AnyTimes()
-			mockClient.EXPECT().LoginCluster(gomock.Any(), gomock.Eq(trueClusterID)).Return(fakeResp, nil).AnyTimes()
-
-			MonitoringOpts.Namespace = OpenShiftMonitoringNS
-
-			// check for prometheus
-
-			client = NewClient("", client.http)
-			err := client.RunMonitoring(PROMETHEUS)
-			Expect(err).NotTo(BeNil())
-			Expect(err.Error()).Should(ContainSubstring("this cluster's version is 4.11 or greater."))
-			Expect(err.Error()).Should(ContainSubstring("Prometheus, AlertManager and Grafana monitoring UIs are deprecated"))
-
-			// check for Grafana
-			client = NewClient("", client.http)
-			err = client.RunMonitoring(GRAFANA)
-			Expect(err).NotTo(BeNil())
-			Expect(err.Error()).Should(ContainSubstring("this cluster's version is 4.11 or greater."))
-			Expect(err.Error()).Should(ContainSubstring("Prometheus, AlertManager and Grafana monitoring UIs are deprecated"))
-
-			// check for Alertmanager
-			client = NewClient("", client.http)
-			err = client.RunMonitoring(ALERTMANAGER)
-			Expect(err).NotTo(BeNil())
-			Expect(err.Error()).Should(ContainSubstring("this cluster's version is 4.11 or greater."))
-			Expect(err.Error()).Should(ContainSubstring("Prometheus, AlertManager and Grafana monitoring UIs are deprecated"))
-		})
-
-		It("should serve thanos monitoring dashboard for cluster version greater than 4.11", func() {
-			mockOcmInterface.EXPECT().GetOCMEnvironment().Return(ocmEnv, nil).AnyTimes()
-			mockClientWithResp.EXPECT().LoginClusterWithResponse(gomock.Any(), gomock.Any()).Return(nil, nil).AnyTimes()
-			mockOcmInterface.EXPECT().GetTargetCluster(trueClusterID).Return(trueClusterID, testClusterID, nil).AnyTimes()
-			mockOcmInterface.EXPECT().GetClusterInfoByID(testClusterID).Return(clusterVersion412, nil).AnyTimes()
-			mockOcmInterface.EXPECT().IsClusterHibernating(gomock.Eq(trueClusterID)).Return(false, nil).AnyTimes()
-			mockOcmInterface.EXPECT().GetOCMAccessToken().Return(&testToken, nil).AnyTimes()
-			mockClientUtil.EXPECT().MakeRawBackplaneAPIClientWithAccessToken(backplaneAPIUri, testToken).Return(mockClient, nil).AnyTimes()
-			mockClient.EXPECT().LoginCluster(gomock.Any(), gomock.Eq(trueClusterID)).Return(fakeResp, nil).AnyTimes()
-
-			MonitoringOpts.KeepAlive = false
-
-			svr := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				_, _ = w.Write([]byte("dummy data"))
-			}))
-
-			defer svr.Close()
-
-			client = NewClient(svr.URL, *svr.Client())
-			err := client.RunMonitoring(THANOS)
-			Expect(err).To(BeNil())
-		})
-
-		It("should serve monitoring dashboard for cluster version lower than 4.11 and openshift monitoring namespace ", func() {
-
-			mockOcmInterface.EXPECT().GetOCMEnvironment().Return(ocmEnv, nil).AnyTimes()
-			mockClientWithResp.EXPECT().LoginClusterWithResponse(gomock.Any(), gomock.Any()).Return(nil, nil).AnyTimes()
-			mockOcmInterface.EXPECT().GetTargetCluster(trueClusterID).Return(trueClusterID, testClusterID, nil).AnyTimes()
-			mockOcmInterface.EXPECT().GetClusterInfoByID(testClusterID).Return(clusterVersion410, nil).AnyTimes()
-			mockOcmInterface.EXPECT().IsClusterHibernating(gomock.Eq(trueClusterID)).Return(false, nil).AnyTimes()
-			mockOcmInterface.EXPECT().GetOCMAccessToken().Return(&testToken, nil).AnyTimes()
-			mockClientUtil.EXPECT().MakeRawBackplaneAPIClientWithAccessToken(backplaneAPIUri, testToken).Return(mockClient, nil).AnyTimes()
-			mockClient.EXPECT().LoginCluster(gomock.Any(), gomock.Eq(trueClusterID)).Return(fakeResp, nil).AnyTimes()
-
-			MonitoringOpts.Namespace = OpenShiftMonitoringNS
-			MonitoringOpts.KeepAlive = false
-			svr := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				_, _ = w.Write([]byte("dummy data"))
-			}))
-			defer svr.Close()
-
-			// check for prometheus
-			client = NewClient(svr.URL, *svr.Client())
-			err := client.RunMonitoring(PROMETHEUS)
-			Expect(err).To(BeNil())
-
-			// check for Thanos
-			client = NewClient(svr.URL, *svr.Client())
-			err = client.RunMonitoring(THANOS)
-			Expect(err).To(BeNil())
-
-			// check for Alertmanager
-			client = NewClient(svr.URL, *svr.Client())
-			err = client.RunMonitoring(ALERTMANAGER)
-			Expect(err).To(BeNil())
-		})
-	})
-})