Merge pull request #9570 from Dentrax/k8s-discovery-v1

Kubernetes SD: Support discovery.k8s.io/v1 EndpointSlice

discovery/kubernetes/endpointslice.go

@@ -23,7 +23,8 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prometheus/common/model"
 	apiv1 "k8s.io/api/core/v1"
-	disv1beta1 "k8s.io/api/discovery/v1beta1"
+	v1 "k8s.io/api/discovery/v1"
+	"k8s.io/api/discovery/v1beta1"
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/client-go/util/workqueue"
 
@@ -94,9 +95,13 @@ func NewEndpointSlice(l log.Logger, svc, eps, pod cache.SharedInformer) *Endpoin
 		// disv1beta1.LabelServiceName so this operation doesn't have to
 		// iterate over all endpoint objects.
 		for _, obj := range e.endpointSliceStore.List() {
-			ep := obj.(*disv1beta1.EndpointSlice)
+			esa, err := e.getEndpointSliceAdaptor(obj)
-			if lv, exists := ep.Labels[disv1beta1.LabelServiceName]; exists && lv == svc.Name {
+			if err != nil {
-				e.enqueue(ep)
+				level.Error(e.logger).Log("msg", "converting to EndpointSlice object failed", "err", err)
+				continue
+			}
+			if lv, exists := esa.labels()[esa.labelServiceName()]; exists && lv == svc.Name {
+				e.enqueue(esa.get())
 			}
 		}
 	}
@@ -170,26 +175,30 @@ func (e *EndpointSlice) process(ctx context.Context, ch chan<- []*targetgroup.Gr
 		send(ctx, ch, &targetgroup.Group{Source: endpointSliceSourceFromNamespaceAndName(namespace, name)})
 		return true
 	}
-	eps, err := convertToEndpointSlice(o)
+
+	esa, err := e.getEndpointSliceAdaptor(o)
 	if err != nil {
 		level.Error(e.logger).Log("msg", "converting to EndpointSlice object failed", "err", err)
 		return true
 	}
-	send(ctx, ch, e.buildEndpointSlice(eps))
+
+	send(ctx, ch, e.buildEndpointSlice(esa))
 	return true
 }
 
-func convertToEndpointSlice(o interface{}) (*disv1beta1.EndpointSlice, error) {
+func (e *EndpointSlice) getEndpointSliceAdaptor(o interface{}) (endpointSliceAdaptor, error) {
-	endpoints, ok := o.(*disv1beta1.EndpointSlice)
+	switch endpointSlice := o.(type) {
-	if ok {
+	case *v1.EndpointSlice:
-		return endpoints, nil
+		return newEndpointSliceAdaptorFromV1(endpointSlice), nil
+	case *v1beta1.EndpointSlice:
+		return newEndpointSliceAdaptorFromV1beta1(endpointSlice), nil
+	default:
+		return nil, errors.Errorf("received unexpected object: %v", o)
 	}
-
-	return nil, errors.Errorf("received unexpected object: %v", o)
 }
 
-func endpointSliceSource(ep *disv1beta1.EndpointSlice) string {
+func endpointSliceSource(ep endpointSliceAdaptor) string {
-	return endpointSliceSourceFromNamespaceAndName(ep.Namespace, ep.Name)
+	return endpointSliceSourceFromNamespaceAndName(ep.namespace(), ep.name())
 }
 
 func endpointSliceSourceFromNamespaceAndName(namespace, name string) string {
@@ -211,69 +220,69 @@ const (
 	endpointSliceEndpointTopologyLabelPresentPrefix = metaLabelPrefix + "endpointslice_endpoint_topology_present_"
 )
 
-func (e *EndpointSlice) buildEndpointSlice(eps *disv1beta1.EndpointSlice) *targetgroup.Group {
+func (e *EndpointSlice) buildEndpointSlice(eps endpointSliceAdaptor) *targetgroup.Group {
 	tg := &targetgroup.Group{
 		Source: endpointSliceSource(eps),
 	}
 	tg.Labels = model.LabelSet{
-		namespaceLabel:                lv(eps.Namespace),
+		namespaceLabel:                lv(eps.namespace()),
-		endpointSliceNameLabel:        lv(eps.Name),
+		endpointSliceNameLabel:        lv(eps.name()),
-		endpointSliceAddressTypeLabel: lv(string(eps.AddressType)),
+		endpointSliceAddressTypeLabel: lv(eps.addressType()),
 	}
 	e.addServiceLabels(eps, tg)
 
 	type podEntry struct {
 		pod          *apiv1.Pod
-		servicePorts []disv1beta1.EndpointPort
+		servicePorts []endpointSlicePortAdaptor
 	}
 	seenPods := map[string]*podEntry{}
 
-	add := func(addr string, ep disv1beta1.Endpoint, port disv1beta1.EndpointPort) {
+	add := func(addr string, ep endpointSliceEndpointAdaptor, port endpointSlicePortAdaptor) {
 		a := addr
-		if port.Port != nil {
+		if port.port() != nil {
-			a = net.JoinHostPort(addr, strconv.FormatUint(uint64(*port.Port), 10))
+			a = net.JoinHostPort(addr, strconv.FormatUint(uint64(*port.port()), 10))
 		}
 
 		target := model.LabelSet{
 			model.AddressLabel: lv(a),
 		}
 
-		if port.Name != nil {
+		if port.name() != nil {
-			target[endpointSlicePortNameLabel] = lv(*port.Name)
+			target[endpointSlicePortNameLabel] = lv(*port.name())
 		}
 
-		if port.Protocol != nil {
+		if port.protocol() != nil {
-			target[endpointSlicePortProtocolLabel] = lv(string(*port.Protocol))
+			target[endpointSlicePortProtocolLabel] = lv(string(*port.protocol()))
 		}
 
-		if port.Port != nil {
+		if port.port() != nil {
-			target[endpointSlicePortLabel] = lv(strconv.FormatUint(uint64(*port.Port), 10))
+			target[endpointSlicePortLabel] = lv(strconv.FormatUint(uint64(*port.port()), 10))
 		}
 
-		if port.AppProtocol != nil {
+		if port.appProtocol() != nil {
-			target[endpointSlicePortAppProtocol] = lv(*port.AppProtocol)
+			target[endpointSlicePortAppProtocol] = lv(*port.appProtocol())
 		}
 
-		if ep.Conditions.Ready != nil {
+		if ep.conditions().ready() != nil {
-			target[endpointSliceEndpointConditionsReadyLabel] = lv(strconv.FormatBool(*ep.Conditions.Ready))
+			target[endpointSliceEndpointConditionsReadyLabel] = lv(strconv.FormatBool(*ep.conditions().ready()))
 		}
 
-		if ep.Hostname != nil {
+		if ep.hostname() != nil {
-			target[endpointSliceEndpointHostnameLabel] = lv(*ep.Hostname)
+			target[endpointSliceEndpointHostnameLabel] = lv(*ep.hostname())
 		}
 
-		if ep.TargetRef != nil {
+		if ep.targetRef() != nil {
-			target[model.LabelName(endpointSliceAddressTargetKindLabel)] = lv(ep.TargetRef.Kind)
+			target[model.LabelName(endpointSliceAddressTargetKindLabel)] = lv(ep.targetRef().Kind)
-			target[model.LabelName(endpointSliceAddressTargetNameLabel)] = lv(ep.TargetRef.Name)
+			target[model.LabelName(endpointSliceAddressTargetNameLabel)] = lv(ep.targetRef().Name)
 		}
 
-		for k, v := range ep.Topology {
+		for k, v := range ep.topology() {
 			ln := strutil.SanitizeLabelName(k)
 			target[model.LabelName(endpointSliceEndpointTopologyLabelPrefix+ln)] = lv(v)
 			target[model.LabelName(endpointSliceEndpointTopologyLabelPresentPrefix+ln)] = presentValue
 		}
 
-		pod := e.resolvePodRef(ep.TargetRef)
+		pod := e.resolvePodRef(ep.targetRef())
 		if pod == nil {
 			// This target is not a Pod, so don't continue with Pod specific logic.
 			tg.Targets = append(tg.Targets, target)
@@ -293,11 +302,11 @@ func (e *EndpointSlice) buildEndpointSlice(eps *disv1beta1.EndpointSlice) *targe
 		// Attach potential container port labels matching the endpoint port.
 		for _, c := range pod.Spec.Containers {
 			for _, cport := range c.Ports {
-				if port.Port == nil {
+				if port.port() == nil {
 					continue
 				}
-				if *port.Port == cport.ContainerPort {
+				if *port.port() == cport.ContainerPort {
-					ports := strconv.FormatUint(uint64(*port.Port), 10)
+					ports := strconv.FormatUint(uint64(*port.port()), 10)
 
 					target[podContainerNameLabel] = lv(c.Name)
 					target[podContainerPortNameLabel] = lv(cport.Name)
@@ -314,9 +323,9 @@ func (e *EndpointSlice) buildEndpointSlice(eps *disv1beta1.EndpointSlice) *targe
 		tg.Targets = append(tg.Targets, target)
 	}
 
-	for _, ep := range eps.Endpoints {
+	for _, ep := range eps.endpoints() {
-		for _, port := range eps.Ports {
+		for _, port := range eps.ports() {
-			for _, addr := range ep.Addresses {
+			for _, addr := range ep.addresses() {
 				add(addr, ep, port)
 			}
 		}
@@ -329,10 +338,10 @@ func (e *EndpointSlice) buildEndpointSlice(eps *disv1beta1.EndpointSlice) *targe
 			for _, cport := range c.Ports {
 				hasSeenPort := func() bool {
 					for _, eport := range pe.servicePorts {
-						if eport.Port == nil {
+						if eport.port() == nil {
 							continue
 						}
-						if cport.ContainerPort == *eport.Port {
+						if cport.ContainerPort == *eport.port() {
 							return true
 						}
 					}
@@ -379,16 +388,16 @@ func (e *EndpointSlice) resolvePodRef(ref *apiv1.ObjectReference) *apiv1.Pod {
 	return obj.(*apiv1.Pod)
 }
 
-func (e *EndpointSlice) addServiceLabels(eps *disv1beta1.EndpointSlice, tg *targetgroup.Group) {
+func (e *EndpointSlice) addServiceLabels(esa endpointSliceAdaptor, tg *targetgroup.Group) {
 	var (
 		svc   = &apiv1.Service{}
 		found bool
 	)
-	svc.Namespace = eps.Namespace
+	svc.Namespace = esa.namespace()
 
 	// Every EndpointSlice object has the Service they belong to in the
 	// kubernetes.io/service-name label.
-	svc.Name, found = eps.Labels[disv1beta1.LabelServiceName]
+	svc.Name, found = esa.labels()[esa.labelServiceName()]
 	if !found {
 		return
 	}

discovery/kubernetes/endpointslice_adaptor.go

@@ -0,0 +1,279 @@
+// Copyright 2020 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package kubernetes
+
+import (
+	corev1 "k8s.io/api/core/v1"
+	v1 "k8s.io/api/discovery/v1"
+	"k8s.io/api/discovery/v1beta1"
+)
+
+// endpointSliceAdaptor is an adaptor for the different EndpointSlice versions
+type endpointSliceAdaptor interface {
+	get() interface{}
+	name() string
+	namespace() string
+	addressType() string
+	endpoints() []endpointSliceEndpointAdaptor
+	ports() []endpointSlicePortAdaptor
+	labels() map[string]string
+	labelServiceName() string
+}
+
+type endpointSlicePortAdaptor interface {
+	name() *string
+	port() *int32
+	protocol() *string
+	appProtocol() *string
+}
+
+type endpointSliceEndpointAdaptor interface {
+	addresses() []string
+	hostname() *string
+	conditions() endpointSliceEndpointConditionsAdaptor
+	targetRef() *corev1.ObjectReference
+	topology() map[string]string
+}
+
+type endpointSliceEndpointConditionsAdaptor interface {
+	ready() *bool
+}
+
+// Adaptor for k8s.io/api/discovery/v1
+type endpointSliceAdaptorV1 struct {
+	endpointSlice *v1.EndpointSlice
+}
+
+func newEndpointSliceAdaptorFromV1(endpointSlice *v1.EndpointSlice) endpointSliceAdaptor {
+	return &endpointSliceAdaptorV1{endpointSlice: endpointSlice}
+}
+
+func (e *endpointSliceAdaptorV1) get() interface{} {
+	return e.endpointSlice
+}
+
+func (e *endpointSliceAdaptorV1) name() string {
+	return e.endpointSlice.ObjectMeta.Name
+}
+
+func (e *endpointSliceAdaptorV1) namespace() string {
+	return e.endpointSlice.ObjectMeta.Namespace
+}
+
+func (e *endpointSliceAdaptorV1) addressType() string {
+	return string(e.endpointSlice.AddressType)
+}
+
+func (e *endpointSliceAdaptorV1) endpoints() []endpointSliceEndpointAdaptor {
+	eps := make([]endpointSliceEndpointAdaptor, 0, len(e.endpointSlice.Endpoints))
+	for i := 0; i < len(e.endpointSlice.Endpoints); i++ {
+		eps = append(eps, newEndpointSliceEndpointAdaptorFromV1(e.endpointSlice.Endpoints[i]))
+	}
+	return eps
+}
+
+func (e *endpointSliceAdaptorV1) ports() []endpointSlicePortAdaptor {
+	ports := make([]endpointSlicePortAdaptor, 0, len(e.endpointSlice.Ports))
+	for i := 0; i < len(e.endpointSlice.Ports); i++ {
+		ports = append(ports, newEndpointSlicePortAdaptorFromV1(e.endpointSlice.Ports[i]))
+	}
+	return ports
+}
+
+func (e *endpointSliceAdaptorV1) labels() map[string]string {
+	return e.endpointSlice.Labels
+}
+
+func (e *endpointSliceAdaptorV1) labelServiceName() string {
+	return v1.LabelServiceName
+}
+
+// Adaptor for k8s.io/api/discovery/v1beta1
+type endpointSliceAdaptorV1Beta1 struct {
+	endpointSlice *v1beta1.EndpointSlice
+}
+
+func newEndpointSliceAdaptorFromV1beta1(endpointSlice *v1beta1.EndpointSlice) endpointSliceAdaptor {
+	return &endpointSliceAdaptorV1Beta1{endpointSlice: endpointSlice}
+}
+
+func (e *endpointSliceAdaptorV1Beta1) get() interface{} {
+	return e.endpointSlice
+}
+
+func (e *endpointSliceAdaptorV1Beta1) name() string {
+	return e.endpointSlice.Name
+}
+
+func (e *endpointSliceAdaptorV1Beta1) namespace() string {
+	return e.endpointSlice.Namespace
+}
+
+func (e *endpointSliceAdaptorV1Beta1) addressType() string {
+	return string(e.endpointSlice.AddressType)
+}
+
+func (e *endpointSliceAdaptorV1Beta1) endpoints() []endpointSliceEndpointAdaptor {
+	eps := make([]endpointSliceEndpointAdaptor, 0, len(e.endpointSlice.Endpoints))
+	for i := 0; i < len(e.endpointSlice.Endpoints); i++ {
+		eps = append(eps, newEndpointSliceEndpointAdaptorFromV1beta1(e.endpointSlice.Endpoints[i]))
+	}
+	return eps
+}
+
+func (e *endpointSliceAdaptorV1Beta1) ports() []endpointSlicePortAdaptor {
+	ports := make([]endpointSlicePortAdaptor, 0, len(e.endpointSlice.Ports))
+	for i := 0; i < len(e.endpointSlice.Ports); i++ {
+		ports = append(ports, newEndpointSlicePortAdaptorFromV1beta1(e.endpointSlice.Ports[i]))
+	}
+	return ports
+}
+
+func (e *endpointSliceAdaptorV1Beta1) labels() map[string]string {
+	return e.endpointSlice.Labels
+}
+
+func (e *endpointSliceAdaptorV1Beta1) labelServiceName() string {
+	return v1beta1.LabelServiceName
+}
+
+type endpointSliceEndpointAdaptorV1 struct {
+	endpoint v1.Endpoint
+}
+
+func newEndpointSliceEndpointAdaptorFromV1(endpoint v1.Endpoint) endpointSliceEndpointAdaptor {
+	return &endpointSliceEndpointAdaptorV1{endpoint: endpoint}
+}
+
+func (e *endpointSliceEndpointAdaptorV1) addresses() []string {
+	return e.endpoint.Addresses
+}
+
+func (e *endpointSliceEndpointAdaptorV1) hostname() *string {
+	return e.endpoint.Hostname
+}
+
+func (e *endpointSliceEndpointAdaptorV1) conditions() endpointSliceEndpointConditionsAdaptor {
+	return newEndpointSliceEndpointConditionsAdaptorFromV1(e.endpoint.Conditions)
+}
+
+func (e *endpointSliceEndpointAdaptorV1) targetRef() *corev1.ObjectReference {
+	return e.endpoint.TargetRef
+}
+
+func (e *endpointSliceEndpointAdaptorV1) topology() map[string]string {
+	return e.endpoint.DeprecatedTopology
+}
+
+type endpointSliceEndpointConditionsAdaptorV1 struct {
+	endpointConditions v1.EndpointConditions
+}
+
+func newEndpointSliceEndpointConditionsAdaptorFromV1(endpointConditions v1.EndpointConditions) endpointSliceEndpointConditionsAdaptor {
+	return &endpointSliceEndpointConditionsAdaptorV1{endpointConditions: endpointConditions}
+}
+
+func (e *endpointSliceEndpointConditionsAdaptorV1) ready() *bool {
+	return e.endpointConditions.Ready
+}
+
+type endpointSliceEndpointAdaptorV1beta1 struct {
+	endpoint v1beta1.Endpoint
+}
+
+func newEndpointSliceEndpointAdaptorFromV1beta1(endpoint v1beta1.Endpoint) endpointSliceEndpointAdaptor {
+	return &endpointSliceEndpointAdaptorV1beta1{endpoint: endpoint}
+}
+
+func (e *endpointSliceEndpointAdaptorV1beta1) addresses() []string {
+	return e.endpoint.Addresses
+}
+
+func (e *endpointSliceEndpointAdaptorV1beta1) hostname() *string {
+	return e.endpoint.Hostname
+}
+
+func (e *endpointSliceEndpointAdaptorV1beta1) conditions() endpointSliceEndpointConditionsAdaptor {
+	return newEndpointSliceEndpointConditionsAdaptorFromV1beta1(e.endpoint.Conditions)
+}
+
+func (e *endpointSliceEndpointAdaptorV1beta1) targetRef() *corev1.ObjectReference {
+	return e.endpoint.TargetRef
+}
+
+func (e *endpointSliceEndpointAdaptorV1beta1) topology() map[string]string {
+	return e.endpoint.Topology
+}
+
+type endpointSliceEndpointConditionsAdaptorV1beta1 struct {
+	endpointConditions v1beta1.EndpointConditions
+}
+
+func newEndpointSliceEndpointConditionsAdaptorFromV1beta1(endpointConditions v1beta1.EndpointConditions) endpointSliceEndpointConditionsAdaptor {
+	return &endpointSliceEndpointConditionsAdaptorV1beta1{endpointConditions: endpointConditions}
+}
+
+func (e *endpointSliceEndpointConditionsAdaptorV1beta1) ready() *bool {
+	return e.endpointConditions.Ready
+}
+
+type endpointSlicePortAdaptorV1 struct {
+	endpointPort v1.EndpointPort
+}
+
+func newEndpointSlicePortAdaptorFromV1(port v1.EndpointPort) endpointSlicePortAdaptor {
+	return &endpointSlicePortAdaptorV1{endpointPort: port}
+}
+
+func (e *endpointSlicePortAdaptorV1) name() *string {
+	return e.endpointPort.Name
+}
+
+func (e *endpointSlicePortAdaptorV1) port() *int32 {
+	return e.endpointPort.Port
+}
+
+func (e *endpointSlicePortAdaptorV1) protocol() *string {
+	val := string(*e.endpointPort.Protocol)
+	return &val
+}
+
+func (e *endpointSlicePortAdaptorV1) appProtocol() *string {
+	return e.endpointPort.AppProtocol
+}
+
+type endpointSlicePortAdaptorV1beta1 struct {
+	endpointPort v1beta1.EndpointPort
+}
+
+func newEndpointSlicePortAdaptorFromV1beta1(port v1beta1.EndpointPort) endpointSlicePortAdaptor {
+	return &endpointSlicePortAdaptorV1beta1{endpointPort: port}
+}
+
+func (e *endpointSlicePortAdaptorV1beta1) name() *string {
+	return e.endpointPort.Name
+}
+
+func (e *endpointSlicePortAdaptorV1beta1) port() *int32 {
+	return e.endpointPort.Port
+}
+
+func (e *endpointSlicePortAdaptorV1beta1) protocol() *string {
+	val := string(*e.endpointPort.Protocol)
+	return &val
+}
+
+func (e *endpointSlicePortAdaptorV1beta1) appProtocol() *string {
+	return e.endpointPort.AppProtocol
+}

discovery/kubernetes/endpointslice_adaptor_test.go

@@ -0,0 +1,74 @@
+// Copyright 2020 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package kubernetes
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	v1 "k8s.io/api/discovery/v1"
+	"k8s.io/api/discovery/v1beta1"
+)
+
+func Test_EndpointSliceAdaptor_v1(t *testing.T) {
+	endpointSlice := makeEndpointSliceV1()
+	adaptor := newEndpointSliceAdaptorFromV1(endpointSlice)
+
+	require.Equal(t, endpointSlice.ObjectMeta.Name, adaptor.name())
+	require.Equal(t, endpointSlice.ObjectMeta.Namespace, adaptor.namespace())
+	require.Equal(t, endpointSlice.AddressType, v1.AddressType(adaptor.addressType()))
+	require.Equal(t, endpointSlice.Labels, adaptor.labels())
+	require.Equal(t, endpointSlice.Labels[v1.LabelServiceName], "testendpoints")
+
+	for i, endpointAdaptor := range adaptor.endpoints() {
+		require.Equal(t, endpointSlice.Endpoints[i].Addresses, endpointAdaptor.addresses())
+		require.Equal(t, endpointSlice.Endpoints[i].Hostname, endpointAdaptor.hostname())
+		require.Equal(t, endpointSlice.Endpoints[i].Conditions.Ready, endpointAdaptor.conditions().ready())
+		require.Equal(t, endpointSlice.Endpoints[i].TargetRef, endpointAdaptor.targetRef())
+		require.Equal(t, endpointSlice.Endpoints[i].DeprecatedTopology, endpointAdaptor.topology())
+	}
+
+	for i, portAdaptor := range adaptor.ports() {
+		require.Equal(t, endpointSlice.Ports[i].Name, portAdaptor.name())
+		require.Equal(t, endpointSlice.Ports[i].Port, portAdaptor.port())
+		require.EqualValues(t, endpointSlice.Ports[i].Protocol, portAdaptor.protocol())
+		require.Equal(t, endpointSlice.Ports[i].AppProtocol, portAdaptor.appProtocol())
+	}
+}
+
+func Test_EndpointSliceAdaptor_v1beta1(t *testing.T) {
+	endpointSlice := makeEndpointSliceV1beta1()
+	adaptor := newEndpointSliceAdaptorFromV1beta1(endpointSlice)
+
+	require.Equal(t, endpointSlice.ObjectMeta.Name, adaptor.name())
+	require.Equal(t, endpointSlice.ObjectMeta.Namespace, adaptor.namespace())
+	require.Equal(t, endpointSlice.AddressType, v1beta1.AddressType(adaptor.addressType()))
+	require.Equal(t, endpointSlice.Labels, adaptor.labels())
+	require.Equal(t, endpointSlice.Labels[v1beta1.LabelServiceName], "testendpoints")
+
+	for i, endpointAdaptor := range adaptor.endpoints() {
+		require.Equal(t, endpointSlice.Endpoints[i].Addresses, endpointAdaptor.addresses())
+		require.Equal(t, endpointSlice.Endpoints[i].Hostname, endpointAdaptor.hostname())
+		require.Equal(t, endpointSlice.Endpoints[i].Conditions.Ready, endpointAdaptor.conditions().ready())
+		require.Equal(t, endpointSlice.Endpoints[i].TargetRef, endpointAdaptor.targetRef())
+		require.Equal(t, endpointSlice.Endpoints[i].Topology, endpointAdaptor.topology())
+	}
+
+	for i, portAdaptor := range adaptor.ports() {
+		require.Equal(t, endpointSlice.Ports[i].Name, portAdaptor.name())
+		require.Equal(t, endpointSlice.Ports[i].Port, portAdaptor.port())
+		require.EqualValues(t, endpointSlice.Ports[i].Protocol, portAdaptor.protocol())
+		require.Equal(t, endpointSlice.Ports[i].AppProtocol, portAdaptor.appProtocol())
+	}
+}

discovery/kubernetes/endpointslice_test.go

@@ -18,8 +18,9 @@ import (
 	"testing"
 
 	"github.com/prometheus/common/model"
-	v1 "k8s.io/api/core/v1"
+	corev1 "k8s.io/api/core/v1"
-	disv1beta1 "k8s.io/api/discovery/v1beta1"
+	v1 "k8s.io/api/discovery/v1"
+	"k8s.io/api/discovery/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
@@ -39,39 +40,81 @@ func int32ptr(i int32) *int32 {
 	return &i
 }
 
-func protocolptr(p v1.Protocol) *v1.Protocol {
+func protocolptr(p corev1.Protocol) *corev1.Protocol {
 	return &p
 }
 
-func makeEndpointSlice() *disv1beta1.EndpointSlice {
+func makeEndpointSliceV1() *v1.EndpointSlice {
-	return &disv1beta1.EndpointSlice{
+	return &v1.EndpointSlice{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "testendpoints",
 			Namespace: "default",
 			Labels: map[string]string{
-				disv1beta1.LabelServiceName: "testendpoints",
+				v1.LabelServiceName: "testendpoints",
 			},
 		},
-		AddressType: disv1beta1.AddressTypeIPv4,
+		AddressType: v1.AddressTypeIPv4,
-		Ports: []disv1beta1.EndpointPort{
+		Ports: []v1.EndpointPort{
+			{
+				Name:        strptr("testport"),
+				Port:        int32ptr(9000),
+				Protocol:    protocolptr(corev1.ProtocolTCP),
+				AppProtocol: strptr("http"),
+			},
+		},
+		Endpoints: []v1.Endpoint{
+			{
+				Addresses:  []string{"1.2.3.4"},
+				Conditions: v1.EndpointConditions{Ready: boolptr(true)},
+				Hostname:   strptr("testendpoint1"),
+				TargetRef:  &corev1.ObjectReference{},
+				DeprecatedTopology: map[string]string{
+					"topology": "value",
+				},
+			}, {
+				Addresses: []string{"2.3.4.5"},
+				Conditions: v1.EndpointConditions{
+					Ready: boolptr(true),
+				},
+			}, {
+				Addresses: []string{"3.4.5.6"},
+				Conditions: v1.EndpointConditions{
+					Ready: boolptr(false),
+				},
+			},
+		},
+	}
+}
+
+func makeEndpointSliceV1beta1() *v1beta1.EndpointSlice {
+	return &v1beta1.EndpointSlice{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "testendpoints",
+			Namespace: "default",
+			Labels: map[string]string{
+				v1beta1.LabelServiceName: "testendpoints",
+			},
+		},
+		AddressType: v1beta1.AddressTypeIPv4,
+		Ports: []v1beta1.EndpointPort{
 			{
 				Name:     strptr("testport"),
 				Port:     int32ptr(9000),
-				Protocol: protocolptr(v1.ProtocolTCP),
+				Protocol: protocolptr(corev1.ProtocolTCP),
 			},
 		},
-		Endpoints: []disv1beta1.Endpoint{
+		Endpoints: []v1beta1.Endpoint{
 			{
 				Addresses: []string{"1.2.3.4"},
 				Hostname:  strptr("testendpoint1"),
 			}, {
 				Addresses: []string{"2.3.4.5"},
-				Conditions: disv1beta1.EndpointConditions{
+				Conditions: v1beta1.EndpointConditions{
 					Ready: boolptr(true),
 				},
 			}, {
 				Addresses: []string{"3.4.5.6"},
-				Conditions: disv1beta1.EndpointConditions{
+				Conditions: v1beta1.EndpointConditions{
 					Ready: boolptr(false),
 				},
 			},
@@ -80,12 +123,66 @@ func makeEndpointSlice() *disv1beta1.EndpointSlice {
 }
 
 func TestEndpointSliceDiscoveryBeforeRun(t *testing.T) {
-	n, c := makeDiscovery(RoleEndpointSlice, NamespaceDiscovery{})
+	n, c := makeDiscoveryWithVersion(RoleEndpointSlice, NamespaceDiscovery{Names: []string{"default"}}, "v1.25.0")
 
 	k8sDiscoveryTest{
 		discovery: n,
 		beforeRun: func() {
-			obj := makeEndpointSlice()
+			obj := makeEndpointSliceV1()
+			c.DiscoveryV1().EndpointSlices(obj.Namespace).Create(context.Background(), obj, metav1.CreateOptions{})
+		},
+		expectedMaxItems: 1,
+		expectedRes: map[string]*targetgroup.Group{
+			"endpointslice/default/testendpoints": {
+				Targets: []model.LabelSet{
+					{
+						"__address__": "1.2.3.4:9000",
+						"__meta_kubernetes_endpointslice_address_target_kind":                "",
+						"__meta_kubernetes_endpointslice_address_target_name":                "",
+						"__meta_kubernetes_endpointslice_endpoint_conditions_ready":          "true",
+						"__meta_kubernetes_endpointslice_endpoint_hostname":                  "testendpoint1",
+						"__meta_kubernetes_endpointslice_endpoint_topology_present_topology": "true",
+						"__meta_kubernetes_endpointslice_endpoint_topology_topology":         "value",
+						"__meta_kubernetes_endpointslice_port":                               "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":                  "http",
+						"__meta_kubernetes_endpointslice_port_name":                          "testport",
+						"__meta_kubernetes_endpointslice_port_protocol":                      "TCP",
+					},
+					{
+						"__address__": "2.3.4.5:9000",
+						"__meta_kubernetes_endpointslice_endpoint_conditions_ready": "true",
+						"__meta_kubernetes_endpointslice_port":                      "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":         "http",
+						"__meta_kubernetes_endpointslice_port_name":                 "testport",
+						"__meta_kubernetes_endpointslice_port_protocol":             "TCP",
+					},
+					{
+						"__address__": "3.4.5.6:9000",
+						"__meta_kubernetes_endpointslice_endpoint_conditions_ready": "false",
+						"__meta_kubernetes_endpointslice_port":                      "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":         "http",
+						"__meta_kubernetes_endpointslice_port_name":                 "testport",
+						"__meta_kubernetes_endpointslice_port_protocol":             "TCP",
+					},
+				},
+				Labels: model.LabelSet{
+					"__meta_kubernetes_endpointslice_address_type": "IPv4",
+					"__meta_kubernetes_namespace":                  "default",
+					"__meta_kubernetes_endpointslice_name":         "testendpoints",
+				},
+				Source: "endpointslice/default/testendpoints",
+			},
+		},
+	}.Run(t)
+}
+
+func TestEndpointSliceDiscoveryBeforeRunV1beta1(t *testing.T) {
+	n, c := makeDiscoveryWithVersion(RoleEndpointSlice, NamespaceDiscovery{Names: []string{"default"}}, "1.20.0")
+
+	k8sDiscoveryTest{
+		discovery: n,
+		beforeRun: func() {
+			obj := makeEndpointSliceV1beta1()
 			c.DiscoveryV1beta1().EndpointSlices(obj.Namespace).Create(context.Background(), obj, metav1.CreateOptions{})
 		},
 		expectedMaxItems: 1,
@@ -126,69 +223,69 @@ func TestEndpointSliceDiscoveryBeforeRun(t *testing.T) {
 }
 
 func TestEndpointSliceDiscoveryAdd(t *testing.T) {
-	obj := &v1.Pod{
+	obj := &corev1.Pod{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "testpod",
 			Namespace: "default",
 			UID:       types.UID("deadbeef"),
 		},
-		Spec: v1.PodSpec{
+		Spec: corev1.PodSpec{
 			NodeName: "testnode",
-			Containers: []v1.Container{
+			Containers: []corev1.Container{
 				{
 					Name: "c1",
-					Ports: []v1.ContainerPort{
+					Ports: []corev1.ContainerPort{
 						{
 							Name:          "mainport",
 							ContainerPort: 9000,
-							Protocol:      v1.ProtocolTCP,
+							Protocol:      corev1.ProtocolTCP,
 						},
 					},
 				},
 				{
 					Name: "c2",
-					Ports: []v1.ContainerPort{
+					Ports: []corev1.ContainerPort{
 						{
 							Name:          "sideport",
 							ContainerPort: 9001,
-							Protocol:      v1.ProtocolTCP,
+							Protocol:      corev1.ProtocolTCP,
 						},
 					},
 				},
 			},
 		},
-		Status: v1.PodStatus{
+		Status: corev1.PodStatus{
 			HostIP: "2.3.4.5",
 			PodIP:  "1.2.3.4",
 		},
 	}
-	n, c := makeDiscovery(RoleEndpointSlice, NamespaceDiscovery{}, obj)
+	n, c := makeDiscoveryWithVersion(RoleEndpointSlice, NamespaceDiscovery{Names: []string{"default"}}, "v1.20.0", obj)
 
 	k8sDiscoveryTest{
 		discovery: n,
 		afterStart: func() {
-			obj := &disv1beta1.EndpointSlice{
+			obj := &v1beta1.EndpointSlice{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "testendpoints",
 					Namespace: "default",
 				},
-				AddressType: disv1beta1.AddressTypeIPv4,
+				AddressType: v1beta1.AddressTypeIPv4,
-				Ports: []disv1beta1.EndpointPort{
+				Ports: []v1beta1.EndpointPort{
 					{
 						Name:     strptr("testport"),
 						Port:     int32ptr(9000),
-						Protocol: protocolptr(v1.ProtocolTCP),
+						Protocol: protocolptr(corev1.ProtocolTCP),
 					},
 				},
-				Endpoints: []disv1beta1.Endpoint{
+				Endpoints: []v1beta1.Endpoint{
 					{
 						Addresses: []string{"4.3.2.1"},
-						TargetRef: &v1.ObjectReference{
+						TargetRef: &corev1.ObjectReference{
 							Kind:      "Pod",
 							Name:      "testpod",
 							Namespace: "default",
 						},
-						Conditions: disv1beta1.EndpointConditions{
+						Conditions: v1beta1.EndpointConditions{
 							Ready: boolptr(false),
 						},
 					},
@@ -247,49 +344,85 @@ func TestEndpointSliceDiscoveryAdd(t *testing.T) {
 }
 
 func TestEndpointSliceDiscoveryDelete(t *testing.T) {
-	n, c := makeDiscovery(RoleEndpointSlice, NamespaceDiscovery{}, makeEndpointSlice())
+	n, c := makeDiscoveryWithVersion(RoleEndpointSlice, NamespaceDiscovery{Names: []string{"default"}}, "v1.21.0", makeEndpointSliceV1())
 
 	k8sDiscoveryTest{
 		discovery: n,
 		afterStart: func() {
-			obj := makeEndpointSlice()
+			obj := makeEndpointSliceV1()
 			c.DiscoveryV1beta1().EndpointSlices(obj.Namespace).Delete(context.Background(), obj.Name, metav1.DeleteOptions{})
 		},
 		expectedMaxItems: 2,
 		expectedRes: map[string]*targetgroup.Group{
 			"endpointslice/default/testendpoints": {
 				Source: "endpointslice/default/testendpoints",
+				Targets: []model.LabelSet{
+					{
+						"__address__": "1.2.3.4:9000",
+						"__meta_kubernetes_endpointslice_address_target_kind":                "",
+						"__meta_kubernetes_endpointslice_address_target_name":                "",
+						"__meta_kubernetes_endpointslice_endpoint_conditions_ready":          "true",
+						"__meta_kubernetes_endpointslice_endpoint_hostname":                  "testendpoint1",
+						"__meta_kubernetes_endpointslice_endpoint_topology_present_topology": "true",
+						"__meta_kubernetes_endpointslice_endpoint_topology_topology":         "value",
+						"__meta_kubernetes_endpointslice_port":                               "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":                  "http",
+						"__meta_kubernetes_endpointslice_port_name":                          "testport",
+						"__meta_kubernetes_endpointslice_port_protocol":                      "TCP",
+					},
+					{
+						"__address__": "2.3.4.5:9000",
+						"__meta_kubernetes_endpointslice_endpoint_conditions_ready": "true",
+						"__meta_kubernetes_endpointslice_port":                      "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":         "http",
+						"__meta_kubernetes_endpointslice_port_name":                 "testport",
+						"__meta_kubernetes_endpointslice_port_protocol":             "TCP",
+					},
+					{
+						"__address__": "3.4.5.6:9000",
+						"__meta_kubernetes_endpointslice_endpoint_conditions_ready": "false",
+						"__meta_kubernetes_endpointslice_port":                      "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":         "http",
+						"__meta_kubernetes_endpointslice_port_name":                 "testport",
+						"__meta_kubernetes_endpointslice_port_protocol":             "TCP",
+					},
+				},
+				Labels: map[model.LabelName]model.LabelValue{
+					"__meta_kubernetes_endpointslice_address_type": "IPv4",
+					"__meta_kubernetes_endpointslice_name":         "testendpoints",
+					"__meta_kubernetes_namespace":                  "default",
+				},
 			},
 		},
 	}.Run(t)
 }
 
 func TestEndpointSliceDiscoveryUpdate(t *testing.T) {
-	n, c := makeDiscovery(RoleEndpointSlice, NamespaceDiscovery{}, makeEndpointSlice())
+	n, c := makeDiscoveryWithVersion(RoleEndpointSlice, NamespaceDiscovery{Names: []string{"default"}}, "v1.21.0", makeEndpointSliceV1())
 
 	k8sDiscoveryTest{
 		discovery: n,
 		afterStart: func() {
-			obj := &disv1beta1.EndpointSlice{
+			obj := &v1beta1.EndpointSlice{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "testendpoints",
 					Namespace: "default",
 				},
-				AddressType: disv1beta1.AddressTypeIPv4,
+				AddressType: v1beta1.AddressTypeIPv4,
-				Ports: []disv1beta1.EndpointPort{
+				Ports: []v1beta1.EndpointPort{
 					{
 						Name:     strptr("testport"),
 						Port:     int32ptr(9000),
-						Protocol: protocolptr(v1.ProtocolTCP),
+						Protocol: protocolptr(corev1.ProtocolTCP),
 					},
 				},
-				Endpoints: []disv1beta1.Endpoint{
+				Endpoints: []v1beta1.Endpoint{
 					{
 						Addresses: []string{"1.2.3.4"},
 						Hostname:  strptr("testendpoint1"),
 					}, {
 						Addresses: []string{"2.3.4.5"},
-						Conditions: disv1beta1.EndpointConditions{
+						Conditions: v1beta1.EndpointConditions{
 							Ready: boolptr(true),
 						},
 					},
@@ -300,18 +433,101 @@ func TestEndpointSliceDiscoveryUpdate(t *testing.T) {
 		expectedMaxItems: 2,
 		expectedRes: map[string]*targetgroup.Group{
 			"endpointslice/default/testendpoints": {
+				Source: "endpointslice/default/testendpoints",
 				Targets: []model.LabelSet{
 					{
 						"__address__": "1.2.3.4:9000",
-						"__meta_kubernetes_endpointslice_endpoint_hostname": "testendpoint1",
+						"__meta_kubernetes_endpointslice_address_target_kind":                "",
-						"__meta_kubernetes_endpointslice_port":              "9000",
+						"__meta_kubernetes_endpointslice_address_target_name":                "",
-						"__meta_kubernetes_endpointslice_port_name":         "testport",
+						"__meta_kubernetes_endpointslice_endpoint_conditions_ready":          "true",
-						"__meta_kubernetes_endpointslice_port_protocol":     "TCP",
+						"__meta_kubernetes_endpointslice_endpoint_hostname":                  "testendpoint1",
+						"__meta_kubernetes_endpointslice_endpoint_topology_present_topology": "true",
+						"__meta_kubernetes_endpointslice_endpoint_topology_topology":         "value",
+						"__meta_kubernetes_endpointslice_port":                               "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":                  "http",
+						"__meta_kubernetes_endpointslice_port_name":                          "testport",
+						"__meta_kubernetes_endpointslice_port_protocol":                      "TCP",
 					},
 					{
 						"__address__": "2.3.4.5:9000",
 						"__meta_kubernetes_endpointslice_endpoint_conditions_ready": "true",
 						"__meta_kubernetes_endpointslice_port":                      "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":         "http",
+						"__meta_kubernetes_endpointslice_port_name":                 "testport",
+						"__meta_kubernetes_endpointslice_port_protocol":             "TCP",
+					},
+					{
+						"__address__": "3.4.5.6:9000",
+						"__meta_kubernetes_endpointslice_endpoint_conditions_ready": "false",
+						"__meta_kubernetes_endpointslice_port":                      "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":         "http",
+						"__meta_kubernetes_endpointslice_port_name":                 "testport",
+						"__meta_kubernetes_endpointslice_port_protocol":             "TCP",
+					},
+				},
+				Labels: model.LabelSet{
+					"__meta_kubernetes_endpointslice_address_type": "IPv4",
+					"__meta_kubernetes_endpointslice_name":         "testendpoints",
+					"__meta_kubernetes_namespace":                  "default",
+				},
+			},
+		},
+	}.Run(t)
+}
+
+func TestEndpointSliceDiscoveryEmptyEndpoints(t *testing.T) {
+	n, c := makeDiscoveryWithVersion(RoleEndpointSlice, NamespaceDiscovery{Names: []string{"default"}}, "v1.21.0", makeEndpointSliceV1())
+
+	k8sDiscoveryTest{
+		discovery: n,
+		afterStart: func() {
+			obj := &v1beta1.EndpointSlice{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "testendpoints",
+					Namespace: "default",
+				},
+				AddressType: v1beta1.AddressTypeIPv4,
+				Ports: []v1beta1.EndpointPort{
+					{
+						Name:     strptr("testport"),
+						Port:     int32ptr(9000),
+						Protocol: protocolptr(corev1.ProtocolTCP),
+					},
+				},
+				Endpoints: []v1beta1.Endpoint{},
+			}
+			c.DiscoveryV1beta1().EndpointSlices(obj.Namespace).Update(context.Background(), obj, metav1.UpdateOptions{})
+		},
+		expectedMaxItems: 2,
+		expectedRes: map[string]*targetgroup.Group{
+			"endpointslice/default/testendpoints": {
+				Targets: []model.LabelSet{
+					{
+						"__address__": "1.2.3.4:9000",
+						"__meta_kubernetes_endpointslice_address_target_kind":                "",
+						"__meta_kubernetes_endpointslice_address_target_name":                "",
+						"__meta_kubernetes_endpointslice_endpoint_conditions_ready":          "true",
+						"__meta_kubernetes_endpointslice_endpoint_hostname":                  "testendpoint1",
+						"__meta_kubernetes_endpointslice_endpoint_topology_present_topology": "true",
+						"__meta_kubernetes_endpointslice_endpoint_topology_topology":         "value",
+						"__meta_kubernetes_endpointslice_port":                               "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":                  "http",
+						"__meta_kubernetes_endpointslice_port_name":                          "testport",
+						"__meta_kubernetes_endpointslice_port_protocol":                      "TCP",
+					},
+					{
+						"__address__": "2.3.4.5:9000",
+						"__meta_kubernetes_endpointslice_endpoint_conditions_ready": "true",
+						"__meta_kubernetes_endpointslice_port":                      "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":         "http",
+						"__meta_kubernetes_endpointslice_port_name":                 "testport",
+						"__meta_kubernetes_endpointslice_port_protocol":             "TCP",
+					},
+					{
+						"__address__": "3.4.5.6:9000",
+						"__meta_kubernetes_endpointslice_endpoint_conditions_ready": "false",
+						"__meta_kubernetes_endpointslice_port":                      "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":         "http",
 						"__meta_kubernetes_endpointslice_port_name":                 "testport",
 						"__meta_kubernetes_endpointslice_port_protocol":             "TCP",
 					},
@@ -327,50 +543,13 @@ func TestEndpointSliceDiscoveryUpdate(t *testing.T) {
 	}.Run(t)
 }
 
-func TestEndpointSliceDiscoveryEmptyEndpoints(t *testing.T) {
-	n, c := makeDiscovery(RoleEndpointSlice, NamespaceDiscovery{}, makeEndpointSlice())
-
-	k8sDiscoveryTest{
-		discovery: n,
-		afterStart: func() {
-			obj := &disv1beta1.EndpointSlice{
-				ObjectMeta: metav1.ObjectMeta{
-					Name:      "testendpoints",
-					Namespace: "default",
-				},
-				AddressType: disv1beta1.AddressTypeIPv4,
-				Ports: []disv1beta1.EndpointPort{
-					{
-						Name:     strptr("testport"),
-						Port:     int32ptr(9000),
-						Protocol: protocolptr(v1.ProtocolTCP),
-					},
-				},
-				Endpoints: []disv1beta1.Endpoint{},
-			}
-			c.DiscoveryV1beta1().EndpointSlices(obj.Namespace).Update(context.Background(), obj, metav1.UpdateOptions{})
-		},
-		expectedMaxItems: 2,
-		expectedRes: map[string]*targetgroup.Group{
-			"endpointslice/default/testendpoints": {
-				Labels: model.LabelSet{
-					"__meta_kubernetes_endpointslice_address_type": "IPv4",
-					"__meta_kubernetes_endpointslice_name":         "testendpoints",
-					"__meta_kubernetes_namespace":                  "default",
-				},
-				Source: "endpointslice/default/testendpoints",
-			},
-		},
-	}.Run(t)
-}
-
 func TestEndpointSliceDiscoveryWithService(t *testing.T) {
-	n, c := makeDiscovery(RoleEndpointSlice, NamespaceDiscovery{}, makeEndpointSlice())
+	n, c := makeDiscoveryWithVersion(RoleEndpointSlice, NamespaceDiscovery{Names: []string{"default"}}, "v1.21.0", makeEndpointSliceV1())
 
 	k8sDiscoveryTest{
 		discovery: n,
 		beforeRun: func() {
-			obj := &v1.Service{
+			obj := &corev1.Service{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "testendpoints",
 					Namespace: "default",
@@ -387,15 +566,22 @@ func TestEndpointSliceDiscoveryWithService(t *testing.T) {
 				Targets: []model.LabelSet{
 					{
 						"__address__": "1.2.3.4:9000",
-						"__meta_kubernetes_endpointslice_endpoint_hostname": "testendpoint1",
+						"__meta_kubernetes_endpointslice_address_target_kind":                "",
-						"__meta_kubernetes_endpointslice_port":              "9000",
+						"__meta_kubernetes_endpointslice_address_target_name":                "",
-						"__meta_kubernetes_endpointslice_port_name":         "testport",
+						"__meta_kubernetes_endpointslice_endpoint_conditions_ready":          "true",
-						"__meta_kubernetes_endpointslice_port_protocol":     "TCP",
+						"__meta_kubernetes_endpointslice_endpoint_hostname":                  "testendpoint1",
+						"__meta_kubernetes_endpointslice_endpoint_topology_present_topology": "true",
+						"__meta_kubernetes_endpointslice_endpoint_topology_topology":         "value",
+						"__meta_kubernetes_endpointslice_port":                               "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":                  "http",
+						"__meta_kubernetes_endpointslice_port_name":                          "testport",
+						"__meta_kubernetes_endpointslice_port_protocol":                      "TCP",
 					},
 					{
 						"__address__": "2.3.4.5:9000",
 						"__meta_kubernetes_endpointslice_endpoint_conditions_ready": "true",
 						"__meta_kubernetes_endpointslice_port":                      "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":         "http",
 						"__meta_kubernetes_endpointslice_port_name":                 "testport",
 						"__meta_kubernetes_endpointslice_port_protocol":             "TCP",
 					},
@@ -403,6 +589,7 @@ func TestEndpointSliceDiscoveryWithService(t *testing.T) {
 						"__address__": "3.4.5.6:9000",
 						"__meta_kubernetes_endpointslice_endpoint_conditions_ready": "false",
 						"__meta_kubernetes_endpointslice_port":                      "9000",
+						"__meta_kubernetes_endpointslice_port_app_protocol":         "http",
 						"__meta_kubernetes_endpointslice_port_name":                 "testport",
 						"__meta_kubernetes_endpointslice_port_protocol":             "TCP",
 					},
@@ -422,12 +609,12 @@ func TestEndpointSliceDiscoveryWithService(t *testing.T) {
 }
 
 func TestEndpointSliceDiscoveryWithServiceUpdate(t *testing.T) {
-	n, c := makeDiscovery(RoleEndpointSlice, NamespaceDiscovery{}, makeEndpointSlice())
+	n, c := makeDiscoveryWithVersion(RoleEndpointSlice, NamespaceDiscovery{Names: []string{"default"}}, "v1.21.0", makeEndpointSliceV1())
 
 	k8sDiscoveryTest{
 		discovery: n,
 		beforeRun: func() {
-			obj := &v1.Service{
+			obj := &corev1.Service{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "testendpoints",
 					Namespace: "default",
@@ -439,7 +626,7 @@ func TestEndpointSliceDiscoveryWithServiceUpdate(t *testing.T) {
 			c.CoreV1().Services(obj.Namespace).Create(context.Background(), obj, metav1.CreateOptions{})
 		},
 		afterStart: func() {
-			obj := &v1.Service{
+			obj := &corev1.Service{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "testendpoints",
 					Namespace: "default",
@@ -494,27 +681,27 @@ func TestEndpointSliceDiscoveryWithServiceUpdate(t *testing.T) {
 }
 
 func TestEndpointSliceDiscoveryNamespaces(t *testing.T) {
-	epOne := makeEndpointSlice()
+	epOne := makeEndpointSliceV1()
 	epOne.Namespace = "ns1"
 	objs := []runtime.Object{
 		epOne,
-		&disv1beta1.EndpointSlice{
+		&v1.EndpointSlice{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "testendpoints",
 				Namespace: "ns2",
 			},
-			AddressType: disv1beta1.AddressTypeIPv4,
+			AddressType: v1.AddressTypeIPv4,
-			Ports: []disv1beta1.EndpointPort{
+			Ports: []v1.EndpointPort{
 				{
 					Name:     strptr("testport"),
 					Port:     int32ptr(9000),
-					Protocol: protocolptr(v1.ProtocolTCP),
+					Protocol: protocolptr(corev1.ProtocolTCP),
 				},
 			},
-			Endpoints: []disv1beta1.Endpoint{
+			Endpoints: []v1.Endpoint{
 				{
 					Addresses: []string{"4.3.2.1"},
-					TargetRef: &v1.ObjectReference{
+					TargetRef: &corev1.ObjectReference{
 						Kind:      "Pod",
 						Name:      "testpod",
 						Namespace: "ns2",
@@ -522,7 +709,7 @@ func TestEndpointSliceDiscoveryNamespaces(t *testing.T) {
 				},
 			},
 		},
-		&v1.Service{
+		&corev1.Service{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "testendpoints",
 				Namespace: "ns1",
@@ -531,28 +718,28 @@ func TestEndpointSliceDiscoveryNamespaces(t *testing.T) {
 				},
 			},
 		},
-		&v1.Pod{
+		&corev1.Pod{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "testpod",
 				Namespace: "ns2",
 				UID:       types.UID("deadbeef"),
 			},
-			Spec: v1.PodSpec{
+			Spec: corev1.PodSpec{
 				NodeName: "testnode",
-				Containers: []v1.Container{
+				Containers: []corev1.Container{
 					{
 						Name: "c1",
-						Ports: []v1.ContainerPort{
+						Ports: []corev1.ContainerPort{
 							{
 								Name:          "mainport",
 								ContainerPort: 9000,
-								Protocol:      v1.ProtocolTCP,
+								Protocol:      corev1.ProtocolTCP,
 							},
 						},
 					},
 				},
 			},
-			Status: v1.PodStatus{
+			Status: corev1.PodStatus{
 				HostIP: "2.3.4.5",
 				PodIP:  "4.3.2.1",
 			},
@@ -632,34 +819,34 @@ func TestEndpointSliceDiscoveryNamespaces(t *testing.T) {
 }
 
 func TestEndpointSliceDiscoveryOwnNamespace(t *testing.T) {
-	epOne := makeEndpointSlice()
+	epOne := makeEndpointSliceV1()
 	epOne.Namespace = "own-ns"
 
-	epTwo := makeEndpointSlice()
+	epTwo := makeEndpointSliceV1()
 	epTwo.Namespace = "non-own-ns"
 
-	podOne := &v1.Pod{
+	podOne := &corev1.Pod{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "testpod",
 			Namespace: "own-ns",
 			UID:       types.UID("deadbeef"),
 		},
-		Spec: v1.PodSpec{
+		Spec: corev1.PodSpec{
 			NodeName: "testnode",
-			Containers: []v1.Container{
+			Containers: []corev1.Container{
 				{
 					Name: "p1",
-					Ports: []v1.ContainerPort{
+					Ports: []corev1.ContainerPort{
 						{
 							Name:          "mainport",
 							ContainerPort: 9000,
-							Protocol:      v1.ProtocolTCP,
+							Protocol:      corev1.ProtocolTCP,
 						},
 					},
 				},
 			},
 		},
-		Status: v1.PodStatus{
+		Status: corev1.PodStatus{
 			HostIP: "2.3.4.5",
 			PodIP:  "4.3.2.1",
 		},

discovery/kubernetes/kubernetes.go

@@ -30,6 +30,7 @@ import (
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/common/version"
 	apiv1 "k8s.io/api/core/v1"
+	disv1 "k8s.io/api/discovery/v1"
 	disv1beta1 "k8s.io/api/discovery/v1beta1"
 	networkv1 "k8s.io/api/networking/v1"
 	"k8s.io/api/networking/v1beta1"
@@ -385,20 +386,56 @@ func (d *Discovery) Run(ctx context.Context, ch chan<- []*targetgroup.Group) {
 
 	switch d.role {
 	case RoleEndpointSlice:
+		// Check "networking.k8s.io/v1" availability with retries.
+		// If "v1" is not available, use "networking.k8s.io/v1beta1" for backward compatibility
+		var v1Supported bool
+		if retryOnError(ctx, 10*time.Second,
+			func() (err error) {
+				v1Supported, err = checkDiscoveryV1Supported(d.client)
+				if err != nil {
+					level.Error(d.logger).Log("msg", "Failed to check networking.k8s.io/v1 availability", "err", err)
+				}
+				return err
+			},
+		) {
+			d.Unlock()
+			return
+		}
+
 		for _, namespace := range namespaces {
-			e := d.client.DiscoveryV1beta1().EndpointSlices(namespace)
+			var informer cache.SharedInformer
-			elw := &cache.ListWatch{
+			if v1Supported {
-				ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
+				e := d.client.DiscoveryV1().EndpointSlices(namespace)
-					options.FieldSelector = d.selectors.endpointslice.field
+				elw := &cache.ListWatch{
-					options.LabelSelector = d.selectors.endpointslice.label
+					ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-					return e.List(ctx, options)
+						options.FieldSelector = d.selectors.endpointslice.field
-				},
+						options.LabelSelector = d.selectors.endpointslice.label
-				WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
+						return e.List(ctx, options)
-					options.FieldSelector = d.selectors.endpointslice.field
+					},
-					options.LabelSelector = d.selectors.endpointslice.label
+					WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-					return e.Watch(ctx, options)
+						options.FieldSelector = d.selectors.endpointslice.field
-				},
+						options.LabelSelector = d.selectors.endpointslice.label
+						return e.Watch(ctx, options)
+					},
+				}
+				informer = cache.NewSharedInformer(elw, &disv1.EndpointSlice{}, resyncPeriod)
+			} else {
+				e := d.client.DiscoveryV1beta1().EndpointSlices(namespace)
+				elw := &cache.ListWatch{
+					ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
+						options.FieldSelector = d.selectors.endpointslice.field
+						options.LabelSelector = d.selectors.endpointslice.label
+						return e.List(ctx, options)
+					},
+					WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
+						options.FieldSelector = d.selectors.endpointslice.field
+						options.LabelSelector = d.selectors.endpointslice.label
+						return e.Watch(ctx, options)
+					},
+				}
+				informer = cache.NewSharedInformer(elw, &disv1beta1.EndpointSlice{}, resyncPeriod)
 			}
+
 			s := d.client.CoreV1().Services(namespace)
 			slw := &cache.ListWatch{
 				ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
@@ -428,7 +465,7 @@ func (d *Discovery) Run(ctx context.Context, ch chan<- []*targetgroup.Group) {
 			eps := NewEndpointSlice(
 				log.With(d.logger, "role", "endpointslice"),
 				cache.NewSharedInformer(slw, &apiv1.Service{}, resyncPeriod),
-				cache.NewSharedInformer(elw, &disv1beta1.EndpointSlice{}, resyncPeriod),
+				informer,
 				cache.NewSharedInformer(plw, &apiv1.Pod{}, resyncPeriod),
 			)
 			d.discoverers = append(d.discoverers, eps)
@@ -694,3 +731,18 @@ func (d *Discovery) newPodsByNodeInformer(plw *cache.ListWatch) cache.SharedInde
 
 	return cache.NewSharedIndexInformer(plw, &apiv1.Pod{}, resyncPeriod, indexers)
 }
+
+func checkDiscoveryV1Supported(client kubernetes.Interface) (bool, error) {
+	k8sVer, err := client.Discovery().ServerVersion()
+	if err != nil {
+		return false, err
+	}
+	semVer, err := utilversion.ParseSemantic(k8sVer.String())
+	if err != nil {
+		return false, err
+	}
+	// The discovery.k8s.io/v1beta1 API version of EndpointSlice will no longer be served in v1.25.
+	// discovery.k8s.io/v1 is available since Kubernetes v1.21
+	// https://kubernetes.io/docs/reference/using-api/deprecation-guide/#v1-25
+	return semVer.Major() >= 1 && semVer.Minor() >= 21, nil
+}