diff --git a/.chloggen/switchk8snamespace.yaml b/.chloggen/switchk8snamespace.yaml
new file mode 100755
index 000000000000..caef1207ae47
--- /dev/null
+++ b/.chloggen/switchk8snamespace.yaml
@@ -0,0 +1,11 @@
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: k8sclusterreceiver
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Switch k8s.namespace metrics to use pdata.
+
+# One or more tracking issues related to the change
+issues: [23437]
diff --git a/receiver/k8sclusterreceiver/internal/collection/collector.go b/receiver/k8sclusterreceiver/internal/collection/collector.go
index 153aee4a48d1..4554232bb568 100644
--- a/receiver/k8sclusterreceiver/internal/collection/collector.go
+++ b/receiver/k8sclusterreceiver/internal/collection/collector.go
@@ -108,7 +108,7 @@ func (dc *DataCollector) SyncMetrics(obj interface{}) {
 	case *corev1.Node:
 		md = ocsToMetrics(node.GetMetrics(o, dc.nodeConditionsToReport, dc.allocatableTypesToReport, dc.settings.TelemetrySettings.Logger))
 	case *corev1.Namespace:
-		md = ocsToMetrics(namespace.GetMetrics(o))
+		md = namespace.GetMetrics(dc.settings, o)
 	case *corev1.ReplicationController:
 		md = ocsToMetrics(replicationcontroller.GetMetrics(o))
 	case *corev1.ResourceQuota:
diff --git a/receiver/k8sclusterreceiver/internal/namespace/doc.go b/receiver/k8sclusterreceiver/internal/namespace/doc.go
new file mode 100644
index 000000000000..b3049e111e3a
--- /dev/null
+++ b/receiver/k8sclusterreceiver/internal/namespace/doc.go
@@ -0,0 +1,6 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//go:generate mdatagen metadata.yaml
+
+package namespace // import "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/namespace"
diff --git a/receiver/k8sclusterreceiver/internal/namespace/documentation.md b/receiver/k8sclusterreceiver/internal/namespace/documentation.md
new file mode 100644
index 000000000000..82ceeedd546f
--- /dev/null
+++ b/receiver/k8sclusterreceiver/internal/namespace/documentation.md
@@ -0,0 +1,29 @@
+[comment]: <> (Code generated by mdatagen. DO NOT EDIT.)
+
+# k8s/namespace
+
+## Default Metrics
+
+The following metrics are emitted by default. Each of them can be disabled by applying the following configuration:
+
+```yaml
+metrics:
+  <metric_name>:
+    enabled: false
+```
+
+### k8s.namespace.phase
+
+The current phase of namespaces (1 for active and 0 for terminating)
+
+| Unit | Metric Type | Value Type |
+| ---- | ----------- | ---------- |
+| 1 | Gauge | Int |
+
+## Resource Attributes
+
+| Name | Description | Values | Enabled |
+| ---- | ----------- | ------ | ------- |
+| k8s.namespace.name | The k8s namespace name. | Any Str | true |
+| k8s.namespace.uid | The k8s namespace uid. | Any Str | true |
+| opencensus.resourcetype | The OpenCensus resource type. | Any Str | true |
diff --git a/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/generated_config.go b/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/generated_config.go
new file mode 100644
index 000000000000..aaf8839aba9b
--- /dev/null
+++ b/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/generated_config.go
@@ -0,0 +1,76 @@
+// Code generated by mdatagen. DO NOT EDIT.
+
+package metadata
+
+import "go.opentelemetry.io/collector/confmap"
+
+// MetricConfig provides common config for a particular metric.
+type MetricConfig struct {
+	Enabled bool `mapstructure:"enabled"`
+
+	enabledSetByUser bool
+}
+
+func (ms *MetricConfig) Unmarshal(parser *confmap.Conf) error {
+	if parser == nil {
+		return nil
+	}
+	err := parser.Unmarshal(ms, confmap.WithErrorUnused())
+	if err != nil {
+		return err
+	}
+	ms.enabledSetByUser = parser.IsSet("enabled")
+	return nil
+}
+
+// MetricsConfig provides config for k8s/namespace metrics.
+type MetricsConfig struct {
+	K8sNamespacePhase MetricConfig `mapstructure:"k8s.namespace.phase"`
+}
+
+func DefaultMetricsConfig() MetricsConfig {
+	return MetricsConfig{
+		K8sNamespacePhase: MetricConfig{
+			Enabled: true,
+		},
+	}
+}
+
+// ResourceAttributeConfig provides common config for a particular resource attribute.
+type ResourceAttributeConfig struct {
+	Enabled bool `mapstructure:"enabled"`
+}
+
+// ResourceAttributesConfig provides config for k8s/namespace resource attributes.
+type ResourceAttributesConfig struct {
+	K8sNamespaceName       ResourceAttributeConfig `mapstructure:"k8s.namespace.name"`
+	K8sNamespaceUID        ResourceAttributeConfig `mapstructure:"k8s.namespace.uid"`
+	OpencensusResourcetype ResourceAttributeConfig `mapstructure:"opencensus.resourcetype"`
+}
+
+func DefaultResourceAttributesConfig() ResourceAttributesConfig {
+	return ResourceAttributesConfig{
+		K8sNamespaceName: ResourceAttributeConfig{
+			Enabled: true,
+		},
+		K8sNamespaceUID: ResourceAttributeConfig{
+			Enabled: true,
+		},
+		OpencensusResourcetype: ResourceAttributeConfig{
+			Enabled: true,
+		},
+	}
+}
+
+// MetricsBuilderConfig is a configuration for k8s/namespace metrics builder.
+type MetricsBuilderConfig struct {
+	Metrics            MetricsConfig            `mapstructure:"metrics"`
+	ResourceAttributes ResourceAttributesConfig `mapstructure:"resource_attributes"`
+}
+
+func DefaultMetricsBuilderConfig() MetricsBuilderConfig {
+	return MetricsBuilderConfig{
+		Metrics:            DefaultMetricsConfig(),
+		ResourceAttributes: DefaultResourceAttributesConfig(),
+	}
+}
diff --git a/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/generated_config_test.go b/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/generated_config_test.go
new file mode 100644
index 000000000000..46a3b57d9192
--- /dev/null
+++ b/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/generated_config_test.go
@@ -0,0 +1,70 @@
+// Code generated by mdatagen. DO NOT EDIT.
+
+package metadata
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+	"github.com/stretchr/testify/require"
+	"go.opentelemetry.io/collector/component"
+	"go.opentelemetry.io/collector/confmap/confmaptest"
+)
+
+func TestMetricsBuilderConfig(t *testing.T) {
+	tests := []struct {
+		name string
+		want MetricsBuilderConfig
+	}{
+		{
+			name: "default",
+			want: DefaultMetricsBuilderConfig(),
+		},
+		{
+			name: "all_set",
+			want: MetricsBuilderConfig{
+				Metrics: MetricsConfig{
+					K8sNamespacePhase: MetricConfig{Enabled: true},
+				},
+				ResourceAttributes: ResourceAttributesConfig{
+					K8sNamespaceName:       ResourceAttributeConfig{Enabled: true},
+					K8sNamespaceUID:        ResourceAttributeConfig{Enabled: true},
+					OpencensusResourcetype: ResourceAttributeConfig{Enabled: true},
+				},
+			},
+		},
+		{
+			name: "none_set",
+			want: MetricsBuilderConfig{
+				Metrics: MetricsConfig{
+					K8sNamespacePhase: MetricConfig{Enabled: false},
+				},
+				ResourceAttributes: ResourceAttributesConfig{
+					K8sNamespaceName:       ResourceAttributeConfig{Enabled: false},
+					K8sNamespaceUID:        ResourceAttributeConfig{Enabled: false},
+					OpencensusResourcetype: ResourceAttributeConfig{Enabled: false},
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cfg := loadMetricsBuilderConfig(t, tt.name)
+			if diff := cmp.Diff(tt.want, cfg, cmpopts.IgnoreUnexported(MetricConfig{}, ResourceAttributeConfig{})); diff != "" {
+				t.Errorf("Config mismatch (-expected +actual):\n%s", diff)
+			}
+		})
+	}
+}
+
+func loadMetricsBuilderConfig(t *testing.T, name string) MetricsBuilderConfig {
+	cm, err := confmaptest.LoadConf(filepath.Join("testdata", "config.yaml"))
+	require.NoError(t, err)
+	sub, err := cm.Sub(name)
+	require.NoError(t, err)
+	cfg := DefaultMetricsBuilderConfig()
+	require.NoError(t, component.UnmarshalConfig(sub, &cfg))
+	return cfg
+}
diff --git a/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/generated_metrics.go b/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/generated_metrics.go
new file mode 100644
index 000000000000..bc691162ce3a
--- /dev/null
+++ b/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/generated_metrics.go
@@ -0,0 +1,206 @@
+// Code generated by mdatagen. DO NOT EDIT.
+
+package metadata
+
+import (
+	"time"
+
+	"go.opentelemetry.io/collector/component"
+	"go.opentelemetry.io/collector/pdata/pcommon"
+	"go.opentelemetry.io/collector/pdata/pmetric"
+	"go.opentelemetry.io/collector/receiver"
+	conventions "go.opentelemetry.io/collector/semconv/v1.18.0"
+)
+
+type metricK8sNamespacePhase struct {
+	data     pmetric.Metric // data buffer for generated metric.
+	config   MetricConfig   // metric config provided by user.
+	capacity int            // max observed number of data points added to the metric.
+}
+
+// init fills k8s.namespace.phase metric with initial data.
+func (m *metricK8sNamespacePhase) init() {
+	m.data.SetName("k8s.namespace.phase")
+	m.data.SetDescription("The current phase of namespaces (1 for active and 0 for terminating)")
+	m.data.SetUnit("1")
+	m.data.SetEmptyGauge()
+}
+
+func (m *metricK8sNamespacePhase) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64) {
+	if !m.config.Enabled {
+		return
+	}
+	dp := m.data.Gauge().DataPoints().AppendEmpty()
+	dp.SetStartTimestamp(start)
+	dp.SetTimestamp(ts)
+	dp.SetIntValue(val)
+}
+
+// updateCapacity saves max length of data point slices that will be used for the slice capacity.
+func (m *metricK8sNamespacePhase) updateCapacity() {
+	if m.data.Gauge().DataPoints().Len() > m.capacity {
+		m.capacity = m.data.Gauge().DataPoints().Len()
+	}
+}
+
+// emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points.
+func (m *metricK8sNamespacePhase) emit(metrics pmetric.MetricSlice) {
+	if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 {
+		m.updateCapacity()
+		m.data.MoveTo(metrics.AppendEmpty())
+		m.init()
+	}
+}
+
+func newMetricK8sNamespacePhase(cfg MetricConfig) metricK8sNamespacePhase {
+	m := metricK8sNamespacePhase{config: cfg}
+	if cfg.Enabled {
+		m.data = pmetric.NewMetric()
+		m.init()
+	}
+	return m
+}
+
+// MetricsBuilder provides an interface for scrapers to report metrics while taking care of all the transformations
+// required to produce metric representation defined in metadata and user config.
+type MetricsBuilder struct {
+	startTime                pcommon.Timestamp   // start time that will be applied to all recorded data points.
+	metricsCapacity          int                 // maximum observed number of metrics per resource.
+	resourceCapacity         int                 // maximum observed number of resource attributes.
+	metricsBuffer            pmetric.Metrics     // accumulates metrics data before emitting.
+	buildInfo                component.BuildInfo // contains version information
+	resourceAttributesConfig ResourceAttributesConfig
+	metricK8sNamespacePhase  metricK8sNamespacePhase
+}
+
+// metricBuilderOption applies changes to default metrics builder.
+type metricBuilderOption func(*MetricsBuilder)
+
+// WithStartTime sets startTime on the metrics builder.
+func WithStartTime(startTime pcommon.Timestamp) metricBuilderOption {
+	return func(mb *MetricsBuilder) {
+		mb.startTime = startTime
+	}
+}
+
+func NewMetricsBuilder(mbc MetricsBuilderConfig, settings receiver.CreateSettings, options ...metricBuilderOption) *MetricsBuilder {
+	mb := &MetricsBuilder{
+		startTime:                pcommon.NewTimestampFromTime(time.Now()),
+		metricsBuffer:            pmetric.NewMetrics(),
+		buildInfo:                settings.BuildInfo,
+		resourceAttributesConfig: mbc.ResourceAttributes,
+		metricK8sNamespacePhase:  newMetricK8sNamespacePhase(mbc.Metrics.K8sNamespacePhase),
+	}
+	for _, op := range options {
+		op(mb)
+	}
+	return mb
+}
+
+// updateCapacity updates max length of metrics and resource attributes that will be used for the slice capacity.
+func (mb *MetricsBuilder) updateCapacity(rm pmetric.ResourceMetrics) {
+	if mb.metricsCapacity < rm.ScopeMetrics().At(0).Metrics().Len() {
+		mb.metricsCapacity = rm.ScopeMetrics().At(0).Metrics().Len()
+	}
+	if mb.resourceCapacity < rm.Resource().Attributes().Len() {
+		mb.resourceCapacity = rm.Resource().Attributes().Len()
+	}
+}
+
+// ResourceMetricsOption applies changes to provided resource metrics.
+type ResourceMetricsOption func(ResourceAttributesConfig, pmetric.ResourceMetrics)
+
+// WithK8sNamespaceName sets provided value as "k8s.namespace.name" attribute for current resource.
+func WithK8sNamespaceName(val string) ResourceMetricsOption {
+	return func(rac ResourceAttributesConfig, rm pmetric.ResourceMetrics) {
+		if rac.K8sNamespaceName.Enabled {
+			rm.Resource().Attributes().PutStr("k8s.namespace.name", val)
+		}
+	}
+}
+
+// WithK8sNamespaceUID sets provided value as "k8s.namespace.uid" attribute for current resource.
+func WithK8sNamespaceUID(val string) ResourceMetricsOption {
+	return func(rac ResourceAttributesConfig, rm pmetric.ResourceMetrics) {
+		if rac.K8sNamespaceUID.Enabled {
+			rm.Resource().Attributes().PutStr("k8s.namespace.uid", val)
+		}
+	}
+}
+
+// WithOpencensusResourcetype sets provided value as "opencensus.resourcetype" attribute for current resource.
+func WithOpencensusResourcetype(val string) ResourceMetricsOption {
+	return func(rac ResourceAttributesConfig, rm pmetric.ResourceMetrics) {
+		if rac.OpencensusResourcetype.Enabled {
+			rm.Resource().Attributes().PutStr("opencensus.resourcetype", val)
+		}
+	}
+}
+
+// WithStartTimeOverride overrides start time for all the resource metrics data points.
+// This option should be only used if different start time has to be set on metrics coming from different resources.
+func WithStartTimeOverride(start pcommon.Timestamp) ResourceMetricsOption {
+	return func(_ ResourceAttributesConfig, rm pmetric.ResourceMetrics) {
+		var dps pmetric.NumberDataPointSlice
+		metrics := rm.ScopeMetrics().At(0).Metrics()
+		for i := 0; i < metrics.Len(); i++ {
+			switch metrics.At(i).Type() {
+			case pmetric.MetricTypeGauge:
+				dps = metrics.At(i).Gauge().DataPoints()
+			case pmetric.MetricTypeSum:
+				dps = metrics.At(i).Sum().DataPoints()
+			}
+			for j := 0; j < dps.Len(); j++ {
+				dps.At(j).SetStartTimestamp(start)
+			}
+		}
+	}
+}
+
+// EmitForResource saves all the generated metrics under a new resource and updates the internal state to be ready for
+// recording another set of data points as part of another resource. This function can be helpful when one scraper
+// needs to emit metrics from several resources. Otherwise calling this function is not required,
+// just `Emit` function can be called instead.
+// Resource attributes should be provided as ResourceMetricsOption arguments.
+func (mb *MetricsBuilder) EmitForResource(rmo ...ResourceMetricsOption) {
+	rm := pmetric.NewResourceMetrics()
+	rm.SetSchemaUrl(conventions.SchemaURL)
+	rm.Resource().Attributes().EnsureCapacity(mb.resourceCapacity)
+	ils := rm.ScopeMetrics().AppendEmpty()
+	ils.Scope().SetName("otelcol/k8sclusterreceiver")
+	ils.Scope().SetVersion(mb.buildInfo.Version)
+	ils.Metrics().EnsureCapacity(mb.metricsCapacity)
+	mb.metricK8sNamespacePhase.emit(ils.Metrics())
+
+	for _, op := range rmo {
+		op(mb.resourceAttributesConfig, rm)
+	}
+	if ils.Metrics().Len() > 0 {
+		mb.updateCapacity(rm)
+		rm.MoveTo(mb.metricsBuffer.ResourceMetrics().AppendEmpty())
+	}
+}
+
+// Emit returns all the metrics accumulated by the metrics builder and updates the internal state to be ready for
+// recording another set of metrics. This function will be responsible for applying all the transformations required to
+// produce metric representation defined in metadata and user config, e.g. delta or cumulative.
+func (mb *MetricsBuilder) Emit(rmo ...ResourceMetricsOption) pmetric.Metrics {
+	mb.EmitForResource(rmo...)
+	metrics := mb.metricsBuffer
+	mb.metricsBuffer = pmetric.NewMetrics()
+	return metrics
+}
+
+// RecordK8sNamespacePhaseDataPoint adds a data point to k8s.namespace.phase metric.
+func (mb *MetricsBuilder) RecordK8sNamespacePhaseDataPoint(ts pcommon.Timestamp, val int64) {
+	mb.metricK8sNamespacePhase.recordDataPoint(mb.startTime, ts, val)
+}
+
+// Reset resets metrics builder to its initial state. It should be used when external metrics source is restarted,
+// and metrics builder should update its startTime and reset it's internal state accordingly.
+func (mb *MetricsBuilder) Reset(options ...metricBuilderOption) {
+	mb.startTime = pcommon.NewTimestampFromTime(time.Now())
+	for _, op := range options {
+		op(mb)
+	}
+}
diff --git a/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/generated_metrics_test.go b/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/generated_metrics_test.go
new file mode 100644
index 000000000000..256b3f77fecf
--- /dev/null
+++ b/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/generated_metrics_test.go
@@ -0,0 +1,123 @@
+// Code generated by mdatagen. DO NOT EDIT.
+
+package metadata
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"go.opentelemetry.io/collector/pdata/pcommon"
+	"go.opentelemetry.io/collector/pdata/pmetric"
+	"go.opentelemetry.io/collector/receiver/receivertest"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest/observer"
+)
+
+type testConfigCollection int
+
+const (
+	testSetDefault testConfigCollection = iota
+	testSetAll
+	testSetNone
+)
+
+func TestMetricsBuilder(t *testing.T) {
+	tests := []struct {
+		name      string
+		configSet testConfigCollection
+	}{
+		{
+			name:      "default",
+			configSet: testSetDefault,
+		},
+		{
+			name:      "all_set",
+			configSet: testSetAll,
+		},
+		{
+			name:      "none_set",
+			configSet: testSetNone,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			start := pcommon.Timestamp(1_000_000_000)
+			ts := pcommon.Timestamp(1_000_001_000)
+			observedZapCore, observedLogs := observer.New(zap.WarnLevel)
+			settings := receivertest.NewNopCreateSettings()
+			settings.Logger = zap.New(observedZapCore)
+			mb := NewMetricsBuilder(loadMetricsBuilderConfig(t, test.name), settings, WithStartTime(start))
+
+			expectedWarnings := 0
+			assert.Equal(t, expectedWarnings, observedLogs.Len())
+
+			defaultMetricsCount := 0
+			allMetricsCount := 0
+
+			defaultMetricsCount++
+			allMetricsCount++
+			mb.RecordK8sNamespacePhaseDataPoint(ts, 1)
+
+			metrics := mb.Emit(WithK8sNamespaceName("attr-val"), WithK8sNamespaceUID("attr-val"), WithOpencensusResourcetype("attr-val"))
+
+			if test.configSet == testSetNone {
+				assert.Equal(t, 0, metrics.ResourceMetrics().Len())
+				return
+			}
+
+			assert.Equal(t, 1, metrics.ResourceMetrics().Len())
+			rm := metrics.ResourceMetrics().At(0)
+			attrCount := 0
+			enabledAttrCount := 0
+			attrVal, ok := rm.Resource().Attributes().Get("k8s.namespace.name")
+			attrCount++
+			assert.Equal(t, mb.resourceAttributesConfig.K8sNamespaceName.Enabled, ok)
+			if mb.resourceAttributesConfig.K8sNamespaceName.Enabled {
+				enabledAttrCount++
+				assert.EqualValues(t, "attr-val", attrVal.Str())
+			}
+			attrVal, ok = rm.Resource().Attributes().Get("k8s.namespace.uid")
+			attrCount++
+			assert.Equal(t, mb.resourceAttributesConfig.K8sNamespaceUID.Enabled, ok)
+			if mb.resourceAttributesConfig.K8sNamespaceUID.Enabled {
+				enabledAttrCount++
+				assert.EqualValues(t, "attr-val", attrVal.Str())
+			}
+			attrVal, ok = rm.Resource().Attributes().Get("opencensus.resourcetype")
+			attrCount++
+			assert.Equal(t, mb.resourceAttributesConfig.OpencensusResourcetype.Enabled, ok)
+			if mb.resourceAttributesConfig.OpencensusResourcetype.Enabled {
+				enabledAttrCount++
+				assert.EqualValues(t, "attr-val", attrVal.Str())
+			}
+			assert.Equal(t, enabledAttrCount, rm.Resource().Attributes().Len())
+			assert.Equal(t, attrCount, 3)
+
+			assert.Equal(t, 1, rm.ScopeMetrics().Len())
+			ms := rm.ScopeMetrics().At(0).Metrics()
+			if test.configSet == testSetDefault {
+				assert.Equal(t, defaultMetricsCount, ms.Len())
+			}
+			if test.configSet == testSetAll {
+				assert.Equal(t, allMetricsCount, ms.Len())
+			}
+			validatedMetrics := make(map[string]bool)
+			for i := 0; i < ms.Len(); i++ {
+				switch ms.At(i).Name() {
+				case "k8s.namespace.phase":
+					assert.False(t, validatedMetrics["k8s.namespace.phase"], "Found a duplicate in the metrics slice: k8s.namespace.phase")
+					validatedMetrics["k8s.namespace.phase"] = true
+					assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type())
+					assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len())
+					assert.Equal(t, "The current phase of namespaces (1 for active and 0 for terminating)", ms.At(i).Description())
+					assert.Equal(t, "1", ms.At(i).Unit())
+					dp := ms.At(i).Gauge().DataPoints().At(0)
+					assert.Equal(t, start, dp.StartTimestamp())
+					assert.Equal(t, ts, dp.Timestamp())
+					assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType())
+					assert.Equal(t, int64(1), dp.IntValue())
+				}
+			}
+		})
+	}
+}
diff --git a/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/testdata/config.yaml b/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/testdata/config.yaml
new file mode 100644
index 000000000000..e9afe02e3aac
--- /dev/null
+++ b/receiver/k8sclusterreceiver/internal/namespace/internal/metadata/testdata/config.yaml
@@ -0,0 +1,23 @@
+default:
+all_set:
+  metrics:
+    k8s.namespace.phase:
+      enabled: true
+  resource_attributes:
+    k8s.namespace.name:
+      enabled: true
+    k8s.namespace.uid:
+      enabled: true
+    opencensus.resourcetype:
+      enabled: true
+none_set:
+  metrics:
+    k8s.namespace.phase:
+      enabled: false
+  resource_attributes:
+    k8s.namespace.name:
+      enabled: false
+    k8s.namespace.uid:
+      enabled: false
+    opencensus.resourcetype:
+      enabled: false
diff --git a/receiver/k8sclusterreceiver/internal/namespace/metadata.yaml b/receiver/k8sclusterreceiver/internal/namespace/metadata.yaml
new file mode 100644
index 000000000000..0cc0ec1c48f0
--- /dev/null
+++ b/receiver/k8sclusterreceiver/internal/namespace/metadata.yaml
@@ -0,0 +1,27 @@
+type: k8s/namespace
+
+sem_conv_version: 1.18.0
+
+resource_attributes:
+  k8s.namespace.uid:
+    description: The k8s namespace uid.
+    type: string
+    enabled: true
+
+  k8s.namespace.name:
+    description: The k8s namespace name.
+    type: string
+    enabled: true
+
+  opencensus.resourcetype:
+    description: The OpenCensus resource type.
+    type: string
+    enabled: true
+
+metrics:
+  k8s.namespace.phase:
+    enabled: true
+    description: The current phase of namespaces (1 for active and 0 for terminating)
+    unit: 1
+    gauge:
+      value_type: int
\ No newline at end of file
diff --git a/receiver/k8sclusterreceiver/internal/namespace/namespaces.go b/receiver/k8sclusterreceiver/internal/namespace/namespaces.go
index 2daef0a2f2b5..833f4d4f9087 100644
--- a/receiver/k8sclusterreceiver/internal/namespace/namespaces.go
+++ b/receiver/k8sclusterreceiver/internal/namespace/namespaces.go
@@ -4,46 +4,21 @@
 package namespace // import "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/namespace"
 
 import (
-	agentmetricspb "github.com/census-instrumentation/opencensus-proto/gen-go/agent/metrics/v1"
-	metricspb "github.com/census-instrumentation/opencensus-proto/gen-go/metrics/v1"
-	resourcepb "github.com/census-instrumentation/opencensus-proto/gen-go/resource/v1"
-	conventions "go.opentelemetry.io/collector/semconv/v1.6.1"
+	"time"
+
+	"go.opentelemetry.io/collector/pdata/pcommon"
+	"go.opentelemetry.io/collector/pdata/pmetric"
+	"go.opentelemetry.io/collector/receiver"
 	corev1 "k8s.io/api/core/v1"
 
-	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/constants"
-	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/utils"
+	imetadata "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/namespace/internal/metadata"
 )
 
-func GetMetrics(ns *corev1.Namespace) []*agentmetricspb.ExportMetricsServiceRequest {
-	metrics := []*metricspb.Metric{
-		{
-			MetricDescriptor: &metricspb.MetricDescriptor{
-				Name:        "k8s.namespace.phase",
-				Description: "The current phase of namespaces (1 for active and 0 for terminating)",
-				Type:        metricspb.MetricDescriptor_GAUGE_INT64,
-			},
-			Timeseries: []*metricspb.TimeSeries{
-				utils.GetInt64TimeSeries(int64(namespacePhaseValues[ns.Status.Phase])),
-			},
-		},
-	}
-
-	return []*agentmetricspb.ExportMetricsServiceRequest{
-		{
-			Resource: getResource(ns),
-			Metrics:  metrics,
-		},
-	}
-}
-
-func getResource(ns *corev1.Namespace) *resourcepb.Resource {
-	return &resourcepb.Resource{
-		Type: constants.K8sType,
-		Labels: map[string]string{
-			constants.K8sKeyNamespaceUID:          string(ns.UID),
-			conventions.AttributeK8SNamespaceName: ns.Namespace,
-		},
-	}
+func GetMetrics(set receiver.CreateSettings, ns *corev1.Namespace) pmetric.Metrics {
+	mb := imetadata.NewMetricsBuilder(imetadata.DefaultMetricsBuilderConfig(), set)
+	ts := pcommon.NewTimestampFromTime(time.Now())
+	mb.RecordK8sNamespacePhaseDataPoint(ts, int64(namespacePhaseValues[ns.Status.Phase]))
+	return mb.Emit(imetadata.WithK8sNamespaceUID(string(ns.UID)), imetadata.WithK8sNamespaceName(ns.Namespace), imetadata.WithOpencensusResourcetype("k8s"))
 }
 
 var namespacePhaseValues = map[corev1.NamespacePhase]int32{
diff --git a/receiver/k8sclusterreceiver/internal/namespace/namespaces_test.go b/receiver/k8sclusterreceiver/internal/namespace/namespaces_test.go
index 8d8723bea158..7c839aa756e9 100644
--- a/receiver/k8sclusterreceiver/internal/namespace/namespaces_test.go
+++ b/receiver/k8sclusterreceiver/internal/namespace/namespaces_test.go
@@ -4,35 +4,33 @@
 package namespace
 
 import (
+	"path/filepath"
 	"testing"
 
-	metricspb "github.com/census-instrumentation/opencensus-proto/gen-go/metrics/v1"
 	"github.com/stretchr/testify/require"
+	"go.opentelemetry.io/collector/receiver/receivertest"
 	corev1 "k8s.io/api/core/v1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 
-	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/constants"
-	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/testutils"
+	"github.com/open-telemetry/opentelemetry-collector-contrib/internal/coreinternal/golden"
+	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/pdatatest/pmetrictest"
 )
 
 func TestNamespaceMetrics(t *testing.T) {
 	n := newNamespace("1")
-
-	actualResourceMetrics := GetMetrics(n)
-
-	require.Equal(t, 1, len(actualResourceMetrics))
-
-	require.Equal(t, 1, len(actualResourceMetrics[0].Metrics))
-	testutils.AssertResource(t, actualResourceMetrics[0].Resource, constants.K8sType,
-		map[string]string{
-			"k8s.namespace.uid":  "test-namespace-1-uid",
-			"k8s.namespace.name": "test-namespace",
-		},
+	m := GetMetrics(receivertest.NewNopCreateSettings(), n)
+
+	expected, err := golden.ReadMetrics(filepath.Join("testdata", "expected.yaml"))
+	require.NoError(t, err)
+	require.NoError(t, pmetrictest.CompareMetrics(expected, m,
+		pmetrictest.IgnoreTimestamp(),
+		pmetrictest.IgnoreStartTimestamp(),
+		pmetrictest.IgnoreResourceMetricsOrder(),
+		pmetrictest.IgnoreMetricsOrder(),
+		pmetrictest.IgnoreScopeMetricsOrder(),
+	),
 	)
-
-	testutils.AssertMetricsInt(t, actualResourceMetrics[0].Metrics[0], "k8s.namespace.phase",
-		metricspb.MetricDescriptor_GAUGE_INT64, 0)
 }
 
 func newNamespace(id string) *corev1.Namespace {
diff --git a/receiver/k8sclusterreceiver/internal/namespace/testdata/expected.yaml b/receiver/k8sclusterreceiver/internal/namespace/testdata/expected.yaml
new file mode 100644
index 000000000000..088d622a2ea6
--- /dev/null
+++ b/receiver/k8sclusterreceiver/internal/namespace/testdata/expected.yaml
@@ -0,0 +1,24 @@
+resourceMetrics:
+  - resource:
+      attributes:
+        - key: k8s.namespace.name
+          value:
+            stringValue: test-namespace
+        - key: k8s.namespace.uid
+          value:
+            stringValue: test-namespace-1-uid
+        - key: opencensus.resourcetype
+          value:
+            stringValue: k8s
+    schemaUrl: https://opentelemetry.io/schemas/1.18.0
+    scopeMetrics:
+      - metrics:
+          - description: The current phase of namespaces (1 for active and 0 for terminating)
+            gauge:
+              dataPoints:
+                - asInt: "0"
+            name: k8s.namespace.phase
+            unit: "1"
+        scope:
+          name: otelcol/k8sclusterreceiver
+          version: latest
\ No newline at end of file
diff --git a/receiver/k8sclusterreceiver/testdata/e2e/expected.yaml b/receiver/k8sclusterreceiver/testdata/e2e/expected.yaml
index 075b920861b2..d89fd2fc9ad8 100644
--- a/receiver/k8sclusterreceiver/testdata/e2e/expected.yaml
+++ b/receiver/k8sclusterreceiver/testdata/e2e/expected.yaml
@@ -10,6 +10,7 @@ resourceMetrics:
         - key: opencensus.resourcetype
           value:
             stringValue: k8s
+    schemaUrl: "https://opentelemetry.io/schemas/1.18.0"
     scopeMetrics:
       - metrics:
           - description: The current phase of namespaces (1 for active and 0 for terminating)
@@ -18,7 +19,10 @@ resourceMetrics:
                 - asInt: "1"
                   timeUnixNano: "1686772769034865545"
             name: k8s.namespace.phase
-        scope: {}
+            unit: "1"
+        scope:
+          name: otelcol/k8sclusterreceiver
+          version: latest
   - resource:
       attributes:
         - key: k8s.namespace.name
@@ -30,6 +34,7 @@ resourceMetrics:
         - key: opencensus.resourcetype
           value:
             stringValue: k8s
+    schemaUrl: "https://opentelemetry.io/schemas/1.18.0"
     scopeMetrics:
       - metrics:
           - description: The current phase of namespaces (1 for active and 0 for terminating)
@@ -38,7 +43,10 @@ resourceMetrics:
                 - asInt: "1"
                   timeUnixNano: "1686772769034865545"
             name: k8s.namespace.phase
-        scope: {}
+            unit: "1"
+        scope:
+          name: otelcol/k8sclusterreceiver
+          version: latest
   - resource:
       attributes:
         - key: k8s.namespace.name
@@ -50,6 +58,7 @@ resourceMetrics:
         - key: opencensus.resourcetype
           value:
             stringValue: k8s
+    schemaUrl: "https://opentelemetry.io/schemas/1.18.0"
     scopeMetrics:
       - metrics:
           - description: The current phase of namespaces (1 for active and 0 for terminating)
@@ -58,7 +67,10 @@ resourceMetrics:
                 - asInt: "1"
                   timeUnixNano: "1686772769034865545"
             name: k8s.namespace.phase
-        scope: {}
+            unit: "1"
+        scope:
+          name: otelcol/k8sclusterreceiver
+          version: latest
   - resource:
       attributes:
         - key: k8s.namespace.name
@@ -70,6 +82,7 @@ resourceMetrics:
         - key: opencensus.resourcetype
           value:
             stringValue: k8s
+    schemaUrl: "https://opentelemetry.io/schemas/1.18.0"
     scopeMetrics:
       - metrics:
           - description: The current phase of namespaces (1 for active and 0 for terminating)
@@ -78,7 +91,10 @@ resourceMetrics:
                 - asInt: "1"
                   timeUnixNano: "1686772769034865545"
             name: k8s.namespace.phase
-        scope: {}
+            unit: "1"
+        scope:
+          name: otelcol/k8sclusterreceiver
+          version: latest
   - resource:
       attributes:
         - key: k8s.namespace.name
@@ -90,6 +106,7 @@ resourceMetrics:
         - key: opencensus.resourcetype
           value:
             stringValue: k8s
+    schemaUrl: "https://opentelemetry.io/schemas/1.18.0"
     scopeMetrics:
       - metrics:
           - description: The current phase of namespaces (1 for active and 0 for terminating)
@@ -98,7 +115,10 @@ resourceMetrics:
                 - asInt: "1"
                   timeUnixNano: "1686772769034865545"
             name: k8s.namespace.phase
-        scope: {}
+            unit: "1"
+        scope:
+          name: otelcol/k8sclusterreceiver
+          version: latest
   - resource:
       attributes:
         - key: k8s.node.name