first pass

Signed-off-by: Sean Holcomb <seanholcomb@gmail.com>

core/pkg/env/metrics.go

@@ -0,0 +1,102 @@
+package env
+
+const (
+	EmitPodAnnotationsMetricEnvVar       = "EMIT_POD_ANNOTATIONS_METRIC"
+	EmitNamespaceAnnotationsMetricEnvVar = "EMIT_NAMESPACE_ANNOTATIONS_METRIC"
+	EmitDeprecatedMetrics                = "EMIT_DEPRECATED_METRICS"
+
+	EmitKsmV1MetricsEnvVar = "EMIT_KSM_V1_METRICS"
+	EmitKsmV1MetricsOnly   = "EMIT_KSM_V1_METRICS_ONLY"
+
+	EmitDeploymentLabelsMetricEnvVar      = "EMIT_DEPLOYMENT_LABELS_METRIC"
+	EmitDeploymentAnnotationsMetricEnvVar = "EMIT_DEPLOYMENT_ANNOTATIONS_METRIC"
+
+	EmitStatefulSetLabelsMetricEnvVar      = "EMIT_STATEFULSET_LABELS_METRIC"
+	EmitStatefulSetAnnotationsMetricEnvVar = "EMIT_STATEFULSET_ANNOTATIONS_METRIC"
+
+	EmitDaemonSetLabelsMetricEnvVar      = "EMIT_DAEMONSET_LABELS_METRIC"
+	EmitDaemonSetAnnotationsMetricEnvVar = "EMIT_DAEMONSET_ANNOTATIONS_METRIC"
+
+	EmitJobLabelsMetricEnvVar      = "EMIT_JOB_LABELS_METRIC"
+	EmitJobAnnotationsMetricEnvVar = "EMIT_JOB_ANNOTATIONS_METRIC"
+
+	EmitCronJobLabelsMetricEnvVar      = "EMIT_CRONJOB_LABELS_METRIC"
+	EmitCronJobAnnotationsMetricEnvVar = "EMIT_CRONJOB_ANNOTATIONS_METRIC"
+
+	EmitReplicaSetLabelsMetricEnvVar      = "EMIT_REPLICASET_LABELS_METRIC"
+	EmitReplicaSetAnnotationsMetricEnvVar = "EMIT_REPLICASET_ANNOTATIONS_METRIC"
+)
+
+// IsEmitNamespaceAnnotationsMetric returns true if cost-model is configured to emit the kube_namespace_annotations metric
+// containing the namespace annotations
+func IsEmitNamespaceAnnotationsMetric() bool {
+	return GetBool(EmitNamespaceAnnotationsMetricEnvVar, false)
+}
+
+// IsEmitPodAnnotationsMetric returns true if cost-model is configured to emit the kube_pod_annotations metric containing
+// pod annotations.
+func IsEmitPodAnnotationsMetric() bool {
+	return GetBool(EmitPodAnnotationsMetricEnvVar, false)
+}
+
+// IsEmitKsmV1Metrics returns true if cost-model is configured to emit all necessary KSM v1
+// metrics that were removed in KSM v2
+func IsEmitKsmV1Metrics() bool {
+	return GetBool(EmitKsmV1MetricsEnvVar, true)
+}
+
+func IsEmitKsmV1MetricsOnly() bool {
+	return GetBool(EmitKsmV1MetricsOnly, false)
+}
+
+func IsEmitDeprecatedMetrics() bool {
+	return GetBool(EmitDeprecatedMetrics, false)
+}
+
+func IsEmitDeploymentLabelsMetric() bool {
+	return GetBool(EmitDeploymentLabelsMetricEnvVar, true)
+}
+
+func IsEmitDeploymentAnnotationsMetric() bool {
+	return GetBool(EmitDeploymentAnnotationsMetricEnvVar, false)
+}
+
+func IsEmitStatefulSetLabelsMetric() bool {
+	return GetBool(EmitStatefulSetLabelsMetricEnvVar, true)
+}
+
+func IsEmitStatefulSetAnnotationsMetric() bool {
+	return GetBool(EmitStatefulSetAnnotationsMetricEnvVar, false)
+}
+
+func IsEmitDaemonSetLabelsMetric() bool {
+	return GetBool(EmitDaemonSetLabelsMetricEnvVar, true)
+}
+
+func IsEmitDaemonSetAnnotationsMetric() bool {
+	return GetBool(EmitDaemonSetAnnotationsMetricEnvVar, false)
+}
+
+func IsEmitJobLabelsMetric() bool {
+	return GetBool(EmitJobLabelsMetricEnvVar, true)
+}
+
+func IsEmitJobAnnotationsMetric() bool {
+	return GetBool(EmitJobAnnotationsMetricEnvVar, false)
+}
+
+func IsEmitCronJobLabelsMetric() bool {
+	return GetBool(EmitCronJobLabelsMetricEnvVar, true)
+}
+
+func IsEmitCronJobAnnotationsMetric() bool {
+	return GetBool(EmitCronJobAnnotationsMetricEnvVar, false)
+}
+
+func IsEmitReplicaSetLabelsMetric() bool {
+	return GetBool(EmitReplicaSetLabelsMetricEnvVar, true)
+}
+
+func IsEmitReplicaSetAnnotationsMetric() bool {
+	return GetBool(EmitReplicaSetAnnotationsMetricEnvVar, false)
+}

core/pkg/model/kubemodel/container.go

@@ -7,18 +7,18 @@ import (
 
 // @bingen:generate:Container
 type Container struct {
-	PodUID            string             `json:"podUid"`
-	Name              string             `json:"name"`
-	ResourceRequests  ResourceQuantities `json:"resourceRequests"`
-	ResourceLimits    ResourceQuantities `json:"resourceLimits"`
-	CPUCoresAllocated float64            `json:"cpuCoresAllocated"`
-	CPUCoreUsageAvg   float64            `json:"cpuCoreUsageAvg"`
-	CPUCoreUsageMax   float64            `json:"cpuCoreUsageMax"`
-	RAMBytesAllocated float64            `json:"ramBytesAllocated"`
-	RAMBytesUsageAvg  float64            `json:"ramBytesUsageAvg"`
-	RAMBytesUsageMax  float64            `json:"ramBytesUsageMax"`
-	Start             time.Time          `json:"start"`
-	End               time.Time          `json:"end"`
+	PodUID                string             `json:"podUid"`
+	Name                  string             `json:"name"`
+	ResourceRequests      ResourceQuantities `json:"resourceRequests"`
+	ResourceLimits        ResourceQuantities `json:"resourceLimits"`
+	CPUCoreAllocationAvg  float64            `json:"cpuCoreAllocationAvg"`
+	CPUCoreUsageAvg       float64            `json:"cpuCoreUsageAvg"`
+	CPUCoreUsageMax       float64            `json:"cpuCoreUsageMax"`
+	RAMBytesAllocationAvg float64            `json:"ramBytesAllocationAvg"`
+	RAMBytesUsageAvg      float64            `json:"ramBytesUsageAvg"`
+	RAMBytesUsageMax      float64            `json:"ramBytesUsageMax"`
+	Start                 time.Time          `json:"start"`
+	End                   time.Time          `json:"end"`
 }
 
 func (c *Container) GetKey() string {

modules/collector-source/pkg/scrape/scrapecontroller.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/opencost/opencost/core/pkg/clustercache"
 	"github.com/opencost/opencost/core/pkg/clusters"
+	coreenv "github.com/opencost/opencost/core/pkg/env"
 	"github.com/opencost/opencost/core/pkg/log"
 	"github.com/opencost/opencost/core/pkg/nodestats"
 	"github.com/opencost/opencost/core/pkg/util/atomic"
@@ -21,6 +22,57 @@ type ScrapeController struct {
 	updater        metric.Updater
 }
 
+// getDefaultMetricFilter builds a MetricFilter from environment variable configuration.
+// Metrics whose corresponding env var is false (the default) are added to the deny set.
+func getDefaultMetricFilter() MetricFilter {
+	f := MetricFilter{}
+	deny := func(name string) { f[name] = struct{}{} }
+
+	if !coreenv.IsEmitPodAnnotationsMetric() {
+		deny(metric.KubePodAnnotations)
+	}
+	if !coreenv.IsEmitNamespaceAnnotationsMetric() {
+		deny(metric.KubeNamespaceAnnotations)
+	}
+	if !coreenv.IsEmitDeploymentLabelsMetric() {
+		deny(metric.DeploymentLabels)
+	}
+	if !coreenv.IsEmitDeploymentAnnotationsMetric() {
+		deny(metric.DeploymentAnnotations)
+	}
+	if !coreenv.IsEmitStatefulSetLabelsMetric() {
+		deny(metric.StatefulSetLabels)
+	}
+	if !coreenv.IsEmitStatefulSetAnnotationsMetric() {
+		deny(metric.StatefulSetAnnotations)
+	}
+	if !coreenv.IsEmitDaemonSetLabelsMetric() {
+		deny(metric.DaemonSetLabels)
+	}
+	if !coreenv.IsEmitDaemonSetAnnotationsMetric() {
+		deny(metric.DaemonSetAnnotations)
+	}
+	if !coreenv.IsEmitJobLabelsMetric() {
+		deny(metric.JobLabels)
+	}
+	if !coreenv.IsEmitJobAnnotationsMetric() {
+		deny(metric.JobAnnotations)
+	}
+	if !coreenv.IsEmitCronJobLabelsMetric() {
+		deny(metric.CronJobLabels)
+	}
+	if !coreenv.IsEmitCronJobAnnotationsMetric() {
+		deny(metric.CronJobAnnotations)
+	}
+	if !coreenv.IsEmitReplicaSetLabelsMetric() {
+		deny(metric.ReplicaSetLabels)
+	}
+	if !coreenv.IsEmitReplicaSetAnnotationsMetric() {
+		deny(metric.ReplicaSetAnnotations)
+	}
+	return f
+}
+
 func NewScrapeController(
 	clusterUID string,
 	scrapeInterval string,
@@ -30,24 +82,26 @@ func NewScrapeController(
 	clusterCache clustercache.ClusterCache,
 	statSummaryClient nodestats.StatSummaryClient,
 ) *ScrapeController {
+	// Start with env-driven defaults, then layer in any caller-supplied entries.
+	filter := getDefaultMetricFilter()
 
 	var scrapers []Scraper
-	clusterInfoScrapper := newClusterInfoScrapper(clusterUID, clusterInfoProvider)
+	clusterInfoScrapper := withFilter(newClusterInfoScrapper(clusterUID, clusterInfoProvider), filter)
 	scrapers = append(scrapers, clusterInfoScrapper)
 
-	clusterCacheScraper := newClusterCacheScraper(clusterCache)
+	clusterCacheScraper := withFilter(newClusterCacheScraper(clusterCache), filter)
 	scrapers = append(scrapers, clusterCacheScraper)
 
-	opencostScraper := newOpenCostScraper()
+	opencostScraper := withFilter(newOpenCostScraper(), filter)
 	scrapers = append(scrapers, opencostScraper)
 
-	statSummaryScraper := newStatSummaryScraper(statSummaryClient, clusterCache)
+	statSummaryScraper := withFilter(newStatSummaryScraper(statSummaryClient, clusterCache), filter)
 	scrapers = append(scrapers, statSummaryScraper)
 
-	networkScraper := newNetworkScraper(networkPort, clusterCache)
+	networkScraper := withFilter(newNetworkScraper(networkPort, clusterCache), filter)
 	scrapers = append(scrapers, networkScraper)
 
-	dcgmScraper := newDCGMScrapper(clusterCache)
+	dcgmScraper := withFilter(newDCGMScrapper(clusterCache), filter)
 	scrapers = append(scrapers, dcgmScraper)
 
 	si, err := util.NewInterval(scrapeInterval)

modules/collector-source/pkg/scrape/scraper.go

@@ -9,6 +9,36 @@ type Scraper interface {
 	Scrape() []metric.Update
 }
 
+// MetricFilter is a set of metric names to suppress from scrape output.
+// An empty or nil filter allows all metrics through.
+type MetricFilter map[string]struct{}
+
+// filteredScraper wraps a Scraper and removes any Update whose Name appears in the filter.
+type filteredScraper struct {
+	inner  Scraper
+	filter MetricFilter
+}
+
+// withFilter returns s wrapped with f so that denied metric names are stripped from Scrape output.
+// If f is empty, s is returned unchanged.
+func withFilter(s Scraper, f MetricFilter) Scraper {
+	if len(f) == 0 {
+		return s
+	}
+	return &filteredScraper{inner: s, filter: f}
+}
+
+func (fs *filteredScraper) Scrape() []metric.Update {
+	results := fs.inner.Scrape()
+	out := results[:0]
+	for _, u := range results {
+		if _, denied := fs.filter[u.Name]; !denied {
+			out = append(out, u)
+		}
+	}
+	return out
+}
+
 type ScrapeFunc func() []metric.Update
 
 func concurrentScrape(scrapeFuncs ...ScrapeFunc) []metric.Update {

modules/collector-source/pkg/scrape/scraper_test.go

@@ -0,0 +1,226 @@
+package scrape
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	coreenv "github.com/opencost/opencost/core/pkg/env"
+	"github.com/opencost/opencost/modules/collector-source/pkg/metric"
+)
+
+// staticScraper is a test double that returns a fixed set of updates.
+type staticScraper struct {
+	updates []metric.Update
+}
+
+func (s *staticScraper) Scrape() []metric.Update { return s.updates }
+
+func updates(names ...string) []metric.Update {
+	out := make([]metric.Update, len(names))
+	for i, n := range names {
+		out[i] = metric.Update{Name: n}
+	}
+	return out
+}
+
+func updateNames(us []metric.Update) []string {
+	names := make([]string, len(us))
+	for i, u := range us {
+		names[i] = u.Name
+	}
+	return names
+}
+
+func TestWithFilter_EmptyFilterReturnsOriginalScraper(t *testing.T) {
+	s := &staticScraper{}
+	wrapped := withFilter(s, MetricFilter{})
+	assert.Same(t, s, wrapped, "empty filter should return the original scraper unchanged")
+}
+
+func TestWithFilter_NilFilterReturnsOriginalScraper(t *testing.T) {
+	s := &staticScraper{}
+	wrapped := withFilter(s, nil)
+	assert.Same(t, s, wrapped, "nil filter should return the original scraper unchanged")
+}
+
+func TestWithFilter_NonEmptyFilterWraps(t *testing.T) {
+	s := &staticScraper{}
+	f := MetricFilter{"some_metric": {}}
+	wrapped := withFilter(s, f)
+	_, isFiltered := wrapped.(*filteredScraper)
+	assert.True(t, isFiltered, "non-empty filter should wrap in a filteredScraper")
+}
+
+func TestFilteredScraper_AllowsMetricsNotInFilter(t *testing.T) {
+	s := &staticScraper{updates: updates("cpu_usage", "memory_usage")}
+	f := MetricFilter{"kube_pod_annotations": {}}
+	wrapped := withFilter(s, f)
+
+	got := wrapped.Scrape()
+	assert.Equal(t, []string{"cpu_usage", "memory_usage"}, updateNames(got))
+}
+
+func TestFilteredScraper_BlocksDeniedMetrics(t *testing.T) {
+	s := &staticScraper{updates: updates("cpu_usage", metric.KubePodAnnotations, "memory_usage")}
+	f := MetricFilter{metric.KubePodAnnotations: {}}
+	wrapped := withFilter(s, f)
+
+	got := wrapped.Scrape()
+	assert.Equal(t, []string{"cpu_usage", "memory_usage"}, updateNames(got))
+}
+
+func TestFilteredScraper_BlocksMultipleDeniedMetrics(t *testing.T) {
+	s := &staticScraper{updates: updates(
+		metric.KubePodAnnotations,
+		"cpu_usage",
+		metric.KubeNamespaceAnnotations,
+		"memory_usage",
+	)}
+	f := MetricFilter{
+		metric.KubePodAnnotations:       {},
+		metric.KubeNamespaceAnnotations: {},
+	}
+	wrapped := withFilter(s, f)
+
+	got := wrapped.Scrape()
+	assert.Equal(t, []string{"cpu_usage", "memory_usage"}, updateNames(got))
+}
+
+func TestFilteredScraper_EmptyResultsPassThrough(t *testing.T) {
+	s := &staticScraper{updates: []metric.Update{}}
+	f := MetricFilter{metric.KubePodAnnotations: {}}
+	wrapped := withFilter(s, f)
+
+	got := wrapped.Scrape()
+	assert.Empty(t, got)
+}
+
+func TestFilteredScraper_AllMetricsDenied(t *testing.T) {
+	s := &staticScraper{updates: updates(metric.KubePodAnnotations, metric.KubeNamespaceAnnotations)}
+	f := MetricFilter{
+		metric.KubePodAnnotations:       {},
+		metric.KubeNamespaceAnnotations: {},
+	}
+	wrapped := withFilter(s, f)
+
+	got := wrapped.Scrape()
+	assert.Empty(t, got)
+}
+
+func TestGetDefaultMetricFilter_PodAnnotationsDisabled(t *testing.T) {
+	t.Setenv(coreenv.EmitPodAnnotationsMetricEnvVar, "false")
+	t.Setenv(coreenv.EmitNamespaceAnnotationsMetricEnvVar, "true")
+
+	f := getDefaultMetricFilter()
+
+	_, podDenied := f[metric.KubePodAnnotations]
+	_, nsDenied := f[metric.KubeNamespaceAnnotations]
+	assert.True(t, podDenied, "pod annotations should be denied when env var is false")
+	assert.False(t, nsDenied, "namespace annotations should be allowed when env var is true")
+}
+
+func TestGetDefaultMetricFilter_NamespaceAnnotationsDisabled(t *testing.T) {
+	t.Setenv(coreenv.EmitPodAnnotationsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitNamespaceAnnotationsMetricEnvVar, "false")
+
+	f := getDefaultMetricFilter()
+
+	_, podDenied := f[metric.KubePodAnnotations]
+	_, nsDenied := f[metric.KubeNamespaceAnnotations]
+	assert.False(t, podDenied, "pod annotations should be allowed when env var is true")
+	assert.True(t, nsDenied, "namespace annotations should be denied when env var is false")
+}
+
+func TestGetDefaultMetricFilter_BothDisabledByDefault(t *testing.T) {
+	t.Setenv(coreenv.EmitPodAnnotationsMetricEnvVar, "")
+	t.Setenv(coreenv.EmitNamespaceAnnotationsMetricEnvVar, "")
+
+	f := getDefaultMetricFilter()
+
+	_, podDenied := f[metric.KubePodAnnotations]
+	_, nsDenied := f[metric.KubeNamespaceAnnotations]
+	assert.True(t, podDenied, "pod annotations should be denied by default")
+	assert.True(t, nsDenied, "namespace annotations should be denied by default")
+}
+
+func TestGetDefaultMetricFilter_AllEnabled(t *testing.T) {
+	t.Setenv(coreenv.EmitPodAnnotationsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitNamespaceAnnotationsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitDeploymentLabelsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitDeploymentAnnotationsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitStatefulSetLabelsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitStatefulSetAnnotationsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitDaemonSetLabelsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitDaemonSetAnnotationsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitJobLabelsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitJobAnnotationsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitCronJobLabelsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitCronJobAnnotationsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitReplicaSetLabelsMetricEnvVar, "true")
+	t.Setenv(coreenv.EmitReplicaSetAnnotationsMetricEnvVar, "true")
+
+	f := getDefaultMetricFilter()
+
+	assert.Empty(t, f, "filter should be empty when all metrics are enabled")
+}
+
+func TestGetDefaultMetricFilter_AnnotationsDefaultFalse(t *testing.T) {
+	// Unset all env vars to exercise pure defaults.
+	for _, v := range []string{
+		coreenv.EmitPodAnnotationsMetricEnvVar,
+		coreenv.EmitNamespaceAnnotationsMetricEnvVar,
+		coreenv.EmitDeploymentAnnotationsMetricEnvVar,
+		coreenv.EmitStatefulSetAnnotationsMetricEnvVar,
+		coreenv.EmitDaemonSetAnnotationsMetricEnvVar,
+		coreenv.EmitJobAnnotationsMetricEnvVar,
+		coreenv.EmitCronJobAnnotationsMetricEnvVar,
+		coreenv.EmitReplicaSetAnnotationsMetricEnvVar,
+	} {
+		t.Setenv(v, "")
+	}
+
+	f := getDefaultMetricFilter()
+
+	for _, name := range []string{
+		metric.KubePodAnnotations,
+		metric.KubeNamespaceAnnotations,
+		metric.DeploymentAnnotations,
+		metric.StatefulSetAnnotations,
+		metric.DaemonSetAnnotations,
+		metric.JobAnnotations,
+		metric.CronJobAnnotations,
+		metric.ReplicaSetAnnotations,
+	} {
+		_, denied := f[name]
+		assert.True(t, denied, "%s should be denied by default", name)
+	}
+}
+
+func TestGetDefaultMetricFilter_LabelsDefaultTrue(t *testing.T) {
+	// Unset all label env vars to exercise pure defaults.
+	for _, v := range []string{
+		coreenv.EmitDeploymentLabelsMetricEnvVar,
+		coreenv.EmitStatefulSetLabelsMetricEnvVar,
+		coreenv.EmitDaemonSetLabelsMetricEnvVar,
+		coreenv.EmitJobLabelsMetricEnvVar,
+		coreenv.EmitCronJobLabelsMetricEnvVar,
+		coreenv.EmitReplicaSetLabelsMetricEnvVar,
+	} {
+		t.Setenv(v, "")
+	}
+
+	f := getDefaultMetricFilter()
+
+	for _, name := range []string{
+		metric.DeploymentLabels,
+		metric.StatefulSetLabels,
+		metric.DaemonSetLabels,
+		metric.JobLabels,
+		metric.CronJobLabels,
+		metric.ReplicaSetLabels,
+	} {
+		_, denied := f[name]
+		assert.False(t, denied, "%s should be allowed by default", name)
+	}
+}

pkg/env/costmodel.go

@@ -62,13 +62,6 @@ const (
 	CollectorDataSourceEnabledEnvVar = "COLLECTOR_DATA_SOURCE_ENABLED"
 	LocalCollectorDirectoryEnvVar    = "LOCAL_COLLECTOR_DIRECTORY"
 
-	EmitPodAnnotationsMetricEnvVar       = "EMIT_POD_ANNOTATIONS_METRIC"
-	EmitNamespaceAnnotationsMetricEnvVar = "EMIT_NAMESPACE_ANNOTATIONS_METRIC"
-	EmitDeprecatedMetrics                = "EMIT_DEPRECATED_METRICS"
-
-	EmitKsmV1MetricsEnvVar = "EMIT_KSM_V1_METRICS"
-	EmitKsmV1MetricsOnly   = "EMIT_KSM_V1_METRICS_ONLY"
-
 	LogCollectionEnabledEnvVar    = "LOG_COLLECTION_ENABLED"
 	ProductAnalyticsEnabledEnvVar = "PRODUCT_ANALYTICS_ENABLED"
 	ErrorReportingEnabledEnvVar   = "ERROR_REPORTING_ENABLED"
@@ -157,32 +150,6 @@ func GetMetricsConfigmapName() string {
 	return env.Get(MetricsConfigmapName, "metrics-config")
 }
 
-// IsEmitNamespaceAnnotationsMetric returns true if cost-model is configured to emit the kube_namespace_annotations metric
-// containing the namespace annotations
-func IsEmitNamespaceAnnotationsMetric() bool {
-	return env.GetBool(EmitNamespaceAnnotationsMetricEnvVar, false)
-}
-
-// IsEmitPodAnnotationsMetric returns true if cost-model is configured to emit the kube_pod_annotations metric containing
-// pod annotations.
-func IsEmitPodAnnotationsMetric() bool {
-	return env.GetBool(EmitPodAnnotationsMetricEnvVar, false)
-}
-
-// IsEmitKsmV1Metrics returns true if cost-model is configured to emit all necessary KSM v1
-// metrics that were removed in KSM v2
-func IsEmitKsmV1Metrics() bool {
-	return env.GetBool(EmitKsmV1MetricsEnvVar, true)
-}
-
-func IsEmitKsmV1MetricsOnly() bool {
-	return env.GetBool(EmitKsmV1MetricsOnly, false)
-}
-
-func IsEmitDeprecatedMetrics() bool {
-	return env.GetBool(EmitDeprecatedMetrics, false)
-}
-
 // GetAWSAccessKeyID returns the environment variable value for AWSAccessKeyIDEnvVar which represents
 // the AWS access key for authentication
 func GetAWSAccessKeyID() string {