@@ -88,7 +88,7 @@ require (

 	github.com/opencontainers/selinux v1.12.0

 	github.com/pelletier/go-toml v1.9.5

 	github.com/pkg/errors v0.9.1

-	github.com/prometheus/client_golang v1.20.5

+	github.com/prometheus/client_golang v1.22.0

 	github.com/rootless-containers/rootlesskit/v2 v2.3.4

 	github.com/sirupsen/logrus v1.9.3

 	github.com/spf13/cobra v1.9.1

@@ -198,7 +198,7 @@ require (

 	github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect

 	github.com/pmezard/go-difflib v1.0.0 // indirect

 	github.com/prometheus/client_model v0.6.1 // indirect

-	github.com/prometheus/common v0.55.0 // indirect

+	github.com/prometheus/common v0.62.0 // indirect

 	github.com/prometheus/procfs v0.15.1 // indirect

 	github.com/sasha-s/go-deadlock v0.3.5 // indirect

 	github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 // indirect

@@ -485,8 +485,8 @@ github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXP

 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=

 github.com/prometheus/client_golang v1.1.0/go.mod h1:I1FGZT9+L76gKKOs5djB6ezCbFQP1xR9D75/vuwEF3g=

 github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU=

-github.com/prometheus/client_golang v1.20.5 h1:cxppBPuYhUnsO6yo/aoRol4L7q7UFfdm+bR9r+8l63Y=

-github.com/prometheus/client_golang v1.20.5/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE=

+github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q=

+github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0=

 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=

 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=

 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=

@@ -496,8 +496,8 @@ github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQy

 github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=

 github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc=

 github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=

-github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc=

-github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8=

+github.com/prometheus/common v0.62.0 h1:xasJaQlnWAeyHdUBeGjXmutelfJHWMRr+Fg4QszZ2Io=

+github.com/prometheus/common v0.62.0/go.mod h1:vyBcEuLSvWos9B1+CyL7JZ2up+uFzXhkqml0W5zIY1I=

 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=

 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=

 github.com/prometheus/procfs v0.0.3/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ=

new file mode 100644

@@ -0,0 +1,30 @@

+// Copyright 2025 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 prometheus

+

+// CollectorFunc is a convenient way to implement a Prometheus Collector

+// without interface boilerplate.

+// This implementation is based on DescribeByCollect method.

+// familiarize yourself to it before using.

+type CollectorFunc func(chan<- Metric)

+

+// Collect calls the defined CollectorFunc function with the provided Metrics channel

+func (f CollectorFunc) Collect(ch chan<- Metric) {

+	f(ch)

+}

+

+// Describe sends the descriptor information using DescribeByCollect

+func (f CollectorFunc) Describe(ch chan<- *Desc) {

+	DescribeByCollect(f, ch)

+}

@@ -189,12 +189,15 @@ func (d *Desc) String() string {

 			fmt.Sprintf("%s=%q", lp.GetName(), lp.GetValue()),

 		)

 	}

-	vlStrings := make([]string, 0, len(d.variableLabels.names))

-	for _, vl := range d.variableLabels.names {

-		if fn, ok := d.variableLabels.labelConstraints[vl]; ok && fn != nil {

-			vlStrings = append(vlStrings, fmt.Sprintf("c(%s)", vl))

-		} else {

-			vlStrings = append(vlStrings, vl)

+	vlStrings := []string{}

+	if d.variableLabels != nil {

+		vlStrings = make([]string, 0, len(d.variableLabels.names))

+		for _, vl := range d.variableLabels.names {

+			if fn, ok := d.variableLabels.labelConstraints[vl]; ok && fn != nil {

+				vlStrings = append(vlStrings, fmt.Sprintf("c(%s)", vl))

+			} else {

+				vlStrings = append(vlStrings, vl)

+			}

 		}

 	}

 	return fmt.Sprintf(

@@ -288,7 +288,7 @@ func NewGoCollector(opts ...func(o *internal.GoCollectorOptions)) Collector {

 }

 func attachOriginalName(desc, origName string) string {

-	return fmt.Sprintf("%s Sourced from %s", desc, origName)

+	return fmt.Sprintf("%s Sourced from %s.", desc, origName)

 }

 // Describe returns all descriptions of the collector.

@@ -14,6 +14,7 @@

 package prometheus

 import (

+	"errors"

 	"fmt"

 	"math"

 	"runtime"

@@ -28,6 +29,11 @@ import (

 	"google.golang.org/protobuf/types/known/timestamppb"

 )

+const (

+	nativeHistogramSchemaMaximum = 8

+	nativeHistogramSchemaMinimum = -4

+)

+

 // nativeHistogramBounds for the frac of observed values. Only relevant for

 // schema > 0. The position in the slice is the schema. (0 is never used, just

 // here for convenience of using the schema directly as the index.)

@@ -330,11 +336,11 @@ func ExponentialBuckets(start, factor float64, count int) []float64 {

 // used for the Buckets field of HistogramOpts.

 //

 // The function panics if 'count' is 0 or negative, if 'min' is 0 or negative.

-func ExponentialBucketsRange(min, max float64, count int) []float64 {

+func ExponentialBucketsRange(minBucket, maxBucket float64, count int) []float64 {

 	if count < 1 {

 		panic("ExponentialBucketsRange count needs a positive count")

 	}

-	if min <= 0 {

+	if minBucket <= 0 {

 		panic("ExponentialBucketsRange min needs to be greater than 0")

 	}

@@ -342,12 +348,12 @@ func ExponentialBucketsRange(min, max float64, count int) []float64 {

 	// max = min*growthFactor^(bucketCount-1)

 	// We know max/min and highest bucket. Solve for growthFactor.

-	growthFactor := math.Pow(max/min, 1.0/float64(count-1))

+	growthFactor := math.Pow(maxBucket/minBucket, 1.0/float64(count-1))

 	// Now that we know growthFactor, solve for each bucket.

 	buckets := make([]float64, count)

 	for i := 1; i <= count; i++ {

-		buckets[i-1] = min * math.Pow(growthFactor, float64(i-1))

+		buckets[i-1] = minBucket * math.Pow(growthFactor, float64(i-1))

 	}

 	return buckets

 }

@@ -858,15 +864,35 @@ func (h *histogram) Write(out *dto.Metric) error {

 // findBucket returns the index of the bucket for the provided value, or

 // len(h.upperBounds) for the +Inf bucket.

 func (h *histogram) findBucket(v float64) int {

-	// TODO(beorn7): For small numbers of buckets (<30), a linear search is

-	// slightly faster than the binary search. If we really care, we could

-	// switch from one search strategy to the other depending on the number

-	// of buckets.

-	//

-	// Microbenchmarks (BenchmarkHistogramNoLabels):

-	// 11 buckets: 38.3 ns/op linear - binary 48.7 ns/op

-	// 100 buckets: 78.1 ns/op linear - binary 54.9 ns/op

-	// 300 buckets: 154 ns/op linear - binary 61.6 ns/op

+	n := len(h.upperBounds)

+	if n == 0 {

+		return 0

+	}

+

+	// Early exit: if v is less than or equal to the first upper bound, return 0

+	if v <= h.upperBounds[0] {

+		return 0

+	}

+

+	// Early exit: if v is greater than the last upper bound, return len(h.upperBounds)

+	if v > h.upperBounds[n-1] {

+		return n

+	}

+

+	// For small arrays, use simple linear search

+	// "magic number" 35 is result of tests on couple different (AWS and baremetal) servers

+	// see more details here: https://github.com/prometheus/client_golang/pull/1662

+	if n < 35 {

+		for i, bound := range h.upperBounds {

+			if v <= bound {

+				return i

+			}

+		}

+		// If v is greater than all upper bounds, return len(h.upperBounds)

+		return n

+	}

+

+	// For larger arrays, use stdlib's binary search

 	return sort.SearchFloat64s(h.upperBounds, v)

 }

@@ -1440,9 +1466,9 @@ func pickSchema(bucketFactor float64) int32 {

 	floor := math.Floor(math.Log2(math.Log2(bucketFactor)))

 	switch {

 	case floor <= -8:

-		return 8

+		return nativeHistogramSchemaMaximum

 	case floor >= 4:

-		return -4

+		return nativeHistogramSchemaMinimum

 	default:

 		return -int32(floor)

 	}

@@ -1835,3 +1861,196 @@ func (n *nativeExemplars) addExemplar(e *dto.Exemplar) {

 		n.exemplars = append(n.exemplars[:nIdx], append([]*dto.Exemplar{e}, append(n.exemplars[nIdx:rIdx], n.exemplars[rIdx+1:]...)...)...)

 	}

 }

+

+type constNativeHistogram struct {

+	desc *Desc

+	dto.Histogram

+	labelPairs []*dto.LabelPair

+}

+

+func validateCount(sum float64, count uint64, negativeBuckets, positiveBuckets map[int]int64, zeroBucket uint64) error {

+	var bucketPopulationSum int64

+	for _, v := range positiveBuckets {

+		bucketPopulationSum += v

+	}

+	for _, v := range negativeBuckets {

+		bucketPopulationSum += v

+	}

+	bucketPopulationSum += int64(zeroBucket)

+

+	// If the sum of observations is NaN, the number of observations must be greater or equal to the sum of all bucket counts.

+	// Otherwise, the number of observations must be equal to the sum of all bucket counts .

+

+	if math.IsNaN(sum) && bucketPopulationSum > int64(count) ||

+		!math.IsNaN(sum) && bucketPopulationSum != int64(count) {

+		return errors.New("the sum of all bucket populations exceeds the count of observations")

+	}

+	return nil

+}

+

+// NewConstNativeHistogram returns a metric representing a Prometheus native histogram with

+// fixed values for the count, sum, and positive/negative/zero bucket counts. As those parameters

+// cannot be changed, the returned value does not implement the Histogram

+// interface (but only the Metric interface). Users of this package will not

+// have much use for it in regular operations. However, when implementing custom

+// OpenTelemetry Collectors, it is useful as a throw-away metric that is generated on the fly

+// to send it to Prometheus in the Collect method.

+//

+// zeroBucket counts all (positive and negative)

+// observations in the zero bucket (with an absolute value less or equal

+// the current threshold).

+// positiveBuckets and negativeBuckets are separate maps for negative and positive

+// observations. The map's value is an int64, counting observations in

+// that bucket. The map's key is the

+// index of the bucket according to the used

+// Schema. Index 0 is for an upper bound of 1 in positive buckets and for a lower bound of -1 in negative buckets.

+// NewConstNativeHistogram returns an error if

+//   - the length of labelValues is not consistent with the variable labels in Desc or if Desc is invalid.

+//   - the schema passed is not between 8 and -4

+//   - the sum of counts in all buckets including the zero bucket does not equal the count if sum is not NaN (or exceeds the count if sum is NaN)

+//

+// See https://opentelemetry.io/docs/specs/otel/compatibility/prometheus_and_openmetrics/#exponential-histograms for more details about the conversion from OTel to Prometheus.

+func NewConstNativeHistogram(

+	desc *Desc,

+	count uint64,

+	sum float64,

+	positiveBuckets, negativeBuckets map[int]int64,

+	zeroBucket uint64,

+	schema int32,

+	zeroThreshold float64,

+	createdTimestamp time.Time,

+	labelValues ...string,

+) (Metric, error) {

+	if desc.err != nil {

+		return nil, desc.err

+	}

+	if err := validateLabelValues(labelValues, len(desc.variableLabels.names)); err != nil {

+		return nil, err

+	}

+	if schema > nativeHistogramSchemaMaximum || schema < nativeHistogramSchemaMinimum {

+		return nil, errors.New("invalid native histogram schema")

+	}

+	if err := validateCount(sum, count, negativeBuckets, positiveBuckets, zeroBucket); err != nil {

+		return nil, err

+	}

+

+	NegativeSpan, NegativeDelta := makeBucketsFromMap(negativeBuckets)

+	PositiveSpan, PositiveDelta := makeBucketsFromMap(positiveBuckets)

+	ret := &constNativeHistogram{

+		desc: desc,

+		Histogram: dto.Histogram{

+			CreatedTimestamp: timestamppb.New(createdTimestamp),

+			Schema:           &schema,

+			ZeroThreshold:    &zeroThreshold,

+			SampleCount:      &count,

+			SampleSum:        &sum,

+

+			NegativeSpan:  NegativeSpan,

+			NegativeDelta: NegativeDelta,

+

+			PositiveSpan:  PositiveSpan,

+			PositiveDelta: PositiveDelta,

+

+			ZeroCount: proto.Uint64(zeroBucket),

+		},

+		labelPairs: MakeLabelPairs(desc, labelValues),

+	}

+	if *ret.ZeroThreshold == 0 && *ret.ZeroCount == 0 && len(ret.PositiveSpan) == 0 && len(ret.NegativeSpan) == 0 {

+		ret.PositiveSpan = []*dto.BucketSpan{{

+			Offset: proto.Int32(0),

+			Length: proto.Uint32(0),

+		}}

+	}

+	return ret, nil

+}

+

+// MustNewConstNativeHistogram is a version of NewConstNativeHistogram that panics where

+// NewConstNativeHistogram would have returned an error.

+func MustNewConstNativeHistogram(

+	desc *Desc,

+	count uint64,

+	sum float64,

+	positiveBuckets, negativeBuckets map[int]int64,

+	zeroBucket uint64,

+	nativeHistogramSchema int32,

+	nativeHistogramZeroThreshold float64,

+	createdTimestamp time.Time,

+	labelValues ...string,

+) Metric {

+	nativehistogram, err := NewConstNativeHistogram(desc,

+		count,

+		sum,

+		positiveBuckets,

+		negativeBuckets,

+		zeroBucket,

+		nativeHistogramSchema,

+		nativeHistogramZeroThreshold,

+		createdTimestamp,

+		labelValues...)

+	if err != nil {

+		panic(err)

+	}

+	return nativehistogram

+}

+

+func (h *constNativeHistogram) Desc() *Desc {

+	return h.desc

+}

+

+func (h *constNativeHistogram) Write(out *dto.Metric) error {

+	out.Histogram = &h.Histogram

+	out.Label = h.labelPairs

+	return nil

+}

+

+func makeBucketsFromMap(buckets map[int]int64) ([]*dto.BucketSpan, []int64) {

+	if len(buckets) == 0 {

+		return nil, nil

+	}

+	var ii []int

+	for k := range buckets {

+		ii = append(ii, k)

+	}

+	sort.Ints(ii)

+

+	var (

+		spans     []*dto.BucketSpan

+		deltas    []int64

+		prevCount int64

+		nextI     int

+	)

+

+	appendDelta := func(count int64) {

+		*spans[len(spans)-1].Length++

+		deltas = append(deltas, count-prevCount)

+		prevCount = count

+	}

+

+	for n, i := range ii {

+		count := buckets[i]

+		// Multiple spans with only small gaps in between are probably

+		// encoded more efficiently as one larger span with a few empty

+		// buckets. Needs some research to find the sweet spot. For now,

+		// we assume that gaps of one or two buckets should not create

+		// a new span.

+		iDelta := int32(i - nextI)

+		if n == 0 || iDelta > 2 {

+			// We have to create a new span, either because we are

+			// at the very beginning, or because we have found a gap

+			// of more than two buckets.

+			spans = append(spans, &dto.BucketSpan{

+				Offset: proto.Int32(iDelta),

+				Length: proto.Uint32(0),

+			})

+		} else {

+			// We have found a small gap (or no gap at all).

+			// Insert empty buckets as needed.

+			for j := int32(0); j < iDelta; j++ {

+				appendDelta(0)

+			}

+		}

+		appendDelta(count)

+		nextI = i + 1

+	}

+	return spans, deltas

+}

@@ -22,17 +22,18 @@ import (

 	"bytes"

 	"fmt"

 	"io"

+	"strconv"

 	"strings"

 )

-func min(a, b int) int {

+func minInt(a, b int) int {

 	if a < b {

 		return a

 	}

 	return b

 }

-func max(a, b int) int {

+func maxInt(a, b int) int {

 	if a > b {

 		return a

 	}

@@ -427,12 +428,12 @@ func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {

 	if codes[0].Tag == 'e' {

 		c := codes[0]

 		i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2

-		codes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2}

+		codes[0] = OpCode{c.Tag, maxInt(i1, i2-n), i2, maxInt(j1, j2-n), j2}

 	}

 	if codes[len(codes)-1].Tag == 'e' {

 		c := codes[len(codes)-1]

 		i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2

-		codes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)}

+		codes[len(codes)-1] = OpCode{c.Tag, i1, minInt(i2, i1+n), j1, minInt(j2, j1+n)}

 	}

 	nn := n + n

 	groups := [][]OpCode{}

@@ -443,12 +444,12 @@ func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {

 		// there is a large range with no changes.

 		if c.Tag == 'e' && i2-i1 > nn {

 			group = append(group, OpCode{

-				c.Tag, i1, min(i2, i1+n),

-				j1, min(j2, j1+n),

+				c.Tag, i1, minInt(i2, i1+n),

+				j1, minInt(j2, j1+n),

 			})

 			groups = append(groups, group)

 			group = []OpCode{}

-			i1, j1 = max(i1, i2-n), max(j1, j2-n)

+			i1, j1 = maxInt(i1, i2-n), maxInt(j1, j2-n)

 		}

 		group = append(group, OpCode{c.Tag, i1, i2, j1, j2})

 	}

@@ -515,7 +516,7 @@ func (m *SequenceMatcher) QuickRatio() float64 {

 // is faster to compute than either .Ratio() or .QuickRatio().

 func (m *SequenceMatcher) RealQuickRatio() float64 {

 	la, lb := len(m.a), len(m.b)

-	return calculateRatio(min(la, lb), la+lb)

+	return calculateRatio(minInt(la, lb), la+lb)

 }

 // Convert range to the "ed" format

@@ -524,7 +525,7 @@ func formatRangeUnified(start, stop int) string {

 	beginning := start + 1 // lines start numbering with one

 	length := stop - start

 	if length == 1 {

-		return fmt.Sprintf("%d", beginning)

+		return strconv.Itoa(beginning)

 	}

 	if length == 0 {

 		beginning-- // empty ranges begin at line just before the range

@@ -66,7 +66,8 @@ func RuntimeMetricsToProm(d *metrics.Description) (string, string, string, bool)

 		name += "_total"

 	}

-	valid := model.IsValidMetricName(model.LabelValue(namespace + "_" + subsystem + "_" + name))

+	// Our current conversion moves to legacy naming, so use legacy validation.

+	valid := model.IsValidLegacyMetricName(namespace + "_" + subsystem + "_" + name)

 	switch d.Kind {

 	case metrics.KindUint64:

 	case metrics.KindFloat64:

@@ -108,15 +108,23 @@ func BuildFQName(namespace, subsystem, name string) string {

 	if name == "" {

 		return ""

 	}

-	switch {

-	case namespace != "" && subsystem != "":

-		return strings.Join([]string{namespace, subsystem, name}, "_")

-	case namespace != "":

-		return strings.Join([]string{namespace, name}, "_")

-	case subsystem != "":

-		return strings.Join([]string{subsystem, name}, "_")

+

+	sb := strings.Builder{}

+	sb.Grow(len(namespace) + len(subsystem) + len(name) + 2)

+

+	if namespace != "" {

+		sb.WriteString(namespace)

+		sb.WriteString("_")

 	}

-	return name

+

+	if subsystem != "" {

+		sb.WriteString(subsystem)

+		sb.WriteString("_")

+	}

+

+	sb.WriteString(name)

+

+	return sb.String()

 }

 type invalidMetric struct {

@@ -23,6 +23,7 @@ import (

 type processCollector struct {

 	collectFn         func(chan<- Metric)

+	describeFn        func(chan<- *Desc)

 	pidFn             func() (int, error)

 	reportErrors      bool

 	cpuTotal          *Desc

@@ -122,26 +123,23 @@ func NewProcessCollector(opts ProcessCollectorOpts) Collector {

 	// Set up process metric collection if supported by the runtime.

 	if canCollectProcess() {

 		c.collectFn = c.processCollect

+		c.describeFn = c.describe

 	} else {

-		c.collectFn = func(ch chan<- Metric) {

-			c.reportError(ch, nil, errors.New("process metrics not supported on this platform"))

-		}

+		c.collectFn = c.errorCollectFn

+		c.describeFn = c.errorDescribeFn

 	}

 	return c

 }

-// Describe returns all descriptions of the collector.

-func (c *processCollector) Describe(ch chan<- *Desc) {

-	ch <- c.cpuTotal

-	ch <- c.openFDs

-	ch <- c.maxFDs

-	ch <- c.vsize

-	ch <- c.maxVsize

-	ch <- c.rss

-	ch <- c.startTime

-	ch <- c.inBytes

-	ch <- c.outBytes

+func (c *processCollector) errorCollectFn(ch chan<- Metric) {

+	c.reportError(ch, nil, errors.New("process metrics not supported on this platform"))

+}

+

+func (c *processCollector) errorDescribeFn(ch chan<- *Desc) {

+	if c.reportErrors {

+		ch <- NewInvalidDesc(errors.New("process metrics not supported on this platform"))

+	}

 }

 // Collect returns the current state of all metrics of the collector.

@@ -149,6 +147,11 @@ func (c *processCollector) Collect(ch chan<- Metric) {

 	c.collectFn(ch)

 }

+// Describe returns all descriptions of the collector.

+func (c *processCollector) Describe(ch chan<- *Desc) {

+	c.describeFn(ch)

+}

+

 func (c *processCollector) reportError(ch chan<- Metric, desc *Desc, err error) {

 	if !c.reportErrors {

 		return

new file mode 100644

@@ -0,0 +1,130 @@

+// Copyright 2024 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.

+

+//go:build darwin && !ios

+

+package prometheus

+

+import (

+	"errors"

+	"fmt"

+	"os"

+	"syscall"

+	"time"

+

+	"golang.org/x/sys/unix"

+)

+

+// notImplementedErr is returned by stub functions that replace cgo functions, when cgo

+// isn't available.

+var notImplementedErr = errors.New("not implemented")

+

+type memoryInfo struct {

+	vsize uint64 // Virtual memory size in bytes

+	rss   uint64 // Resident memory size in bytes

+}

+

+func canCollectProcess() bool {

+	return true

+}

+

+func getSoftLimit(which int) (uint64, error) {

+	rlimit := syscall.Rlimit{}

+

+	if err := syscall.Getrlimit(which, &rlimit); err != nil {

+		return 0, err

+	}

+

+	return rlimit.Cur, nil

+}

+

+func getOpenFileCount() (float64, error) {

+	// Alternately, the undocumented proc_pidinfo(PROC_PIDLISTFDS) can be used to

+	// return a list of open fds, but that requires a way to call C APIs.  The

+	// benefits, however, include fewer system calls and not failing when at the

+	// open file soft limit.

+

+	if dir, err := os.Open("/dev/fd"); err != nil {

+		return 0.0, err

+	} else {

+		defer dir.Close()

+

+		// Avoid ReadDir(), as it calls stat(2) on each descriptor.  Not only is

+		// that info not used, but KQUEUE descriptors fail stat(2), which causes

+		// the whole method to fail.

+		if names, err := dir.Readdirnames(0); err != nil {

+			return 0.0, err

+		} else {

+			// Subtract 1 to ignore the open /dev/fd descriptor above.

+			return float64(len(names) - 1), nil

+		}

+	}

+}

+

+func (c *processCollector) processCollect(ch chan<- Metric) {

+	if procs, err := unix.SysctlKinfoProcSlice("kern.proc.pid", os.Getpid()); err == nil {

+		if len(procs) == 1 {

+			startTime := float64(procs[0].Proc.P_starttime.Nano() / 1e9)

+			ch <- MustNewConstMetric(c.startTime, GaugeValue, startTime)

+		} else {

+			err = fmt.Errorf("sysctl() returned %d proc structs (expected 1)", len(procs))

+			c.reportError(ch, c.startTime, err)

+		}

+	} else {

+		c.reportError(ch, c.startTime, err)

+	}

+

+	// The proc structure returned by kern.proc.pid above has an Rusage member,

+	// but it is not filled in, so it needs to be fetched by getrusage(2).  For

+	// that call, the UTime, STime, and Maxrss members are filled out, but not

+	// Ixrss, Idrss, or Isrss for the memory usage.  Memory stats will require

+	// access to the C API to call task_info(TASK_BASIC_INFO).

+	rusage := unix.Rusage{}

+

+	if err := unix.Getrusage(syscall.RUSAGE_SELF, &rusage); err == nil {

+		cpuTime := time.Duration(rusage.Stime.Nano() + rusage.Utime.Nano()).Seconds()

+		ch <- MustNewConstMetric(c.cpuTotal, CounterValue, cpuTime)

+	} else {

+		c.reportError(ch, c.cpuTotal, err)

+	}

+

+	if memInfo, err := getMemory(); err == nil {

+		ch <- MustNewConstMetric(c.rss, GaugeValue, float64(memInfo.rss))

+		ch <- MustNewConstMetric(c.vsize, GaugeValue, float64(memInfo.vsize))

+	} else if !errors.Is(err, notImplementedErr) {

+		// Don't report an error when support is not compiled in.

+		c.reportError(ch, c.rss, err)

+		c.reportError(ch, c.vsize, err)

+	}

+

+	if fds, err := getOpenFileCount(); err == nil {

+		ch <- MustNewConstMetric(c.openFDs, GaugeValue, fds)

+	} else {

+		c.reportError(ch, c.openFDs, err)

+	}

+

+	if openFiles, err := getSoftLimit(syscall.RLIMIT_NOFILE); err == nil {

+		ch <- MustNewConstMetric(c.maxFDs, GaugeValue, float64(openFiles))

+	} else {

+		c.reportError(ch, c.maxFDs, err)

+	}

+

+	if addressSpace, err := getSoftLimit(syscall.RLIMIT_AS); err == nil {

+		ch <- MustNewConstMetric(c.maxVsize, GaugeValue, float64(addressSpace))

+	} else {

+		c.reportError(ch, c.maxVsize, err)

+	}

+

+	// TODO: socket(PF_SYSTEM) to fetch "com.apple.network.statistics" might

+	//  be able to get the per-process network send/receive counts.

+}

deleted file mode 100644

@@ -1,26 +0,0 @@

-// Copyright 2019 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.

-

-//go:build js

-// +build js

-

-package prometheus

-

-func canCollectProcess() bool {

-	return false

-}

-

-func (c *processCollector) processCollect(ch chan<- Metric) {

-	// noop on this platform

-	return

-}

new file mode 100644

@@ -0,0 +1,84 @@

+// Copyright 2024 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.

+

+//go:build darwin && !ios && cgo

+

+#include <mach/mach_init.h>

+#include <mach/task.h>

+#include <mach/mach_vm.h>

+

+// The compiler warns that mach/shared_memory_server.h is deprecated, and to use

+// mach/shared_region.h instead.  But that doesn't define

+// SHARED_DATA_REGION_SIZE or SHARED_TEXT_REGION_SIZE, so redefine them here and

+// avoid a warning message when running tests.

+#define GLOBAL_SHARED_TEXT_SEGMENT      0x90000000U

+#define SHARED_DATA_REGION_SIZE         0x10000000

+#define SHARED_TEXT_REGION_SIZE         0x10000000

+

+

+int get_memory_info(unsigned long long *rss, unsigned long long *vsize)

+{

+    // This is lightly adapted from how ps(1) obtains its memory info.

+    // https://github.com/apple-oss-distributions/adv_cmds/blob/8744084ea0ff41ca4bb96b0f9c22407d0e48e9b7/ps/tasks.c#L109

+

+    kern_return_t               error;

+    task_t                      task = MACH_PORT_NULL;

+    mach_task_basic_info_data_t info;

+    mach_msg_type_number_t      info_count = MACH_TASK_BASIC_INFO_COUNT;

+

+    error = task_info(

+                mach_task_self(),

+                MACH_TASK_BASIC_INFO,

+                (task_info_t) &info,

+                &info_count );

+

+    if( error != KERN_SUCCESS )

+    {

+        return error;

+    }

+

+    *rss   = info.resident_size;

+    *vsize = info.virtual_size;

+

+    {

+        vm_region_basic_info_data_64_t    b_info;

+        mach_vm_address_t                 address = GLOBAL_SHARED_TEXT_SEGMENT;

+        mach_vm_size_t                    size;

+        mach_port_t                       object_name;

+

+        /*

+         * try to determine if this task has the split libraries

+         * mapped in... if so, adjust its virtual size down by

+         * the 2 segments that are used for split libraries

+         */

+        info_count = VM_REGION_BASIC_INFO_COUNT_64;

+

+        error = mach_vm_region(

+                    mach_task_self(),

+                    &address,

+                    &size,

+                    VM_REGION_BASIC_INFO_64,

+                    (vm_region_info_t) &b_info,

+                    &info_count,

+                    &object_name);

+

+        if (error == KERN_SUCCESS) {

+            if (b_info.reserved && size == (SHARED_TEXT_REGION_SIZE) &&

+                *vsize > (SHARED_TEXT_REGION_SIZE + SHARED_DATA_REGION_SIZE)) {

+                    *vsize -= (SHARED_TEXT_REGION_SIZE + SHARED_DATA_REGION_SIZE);

+            }

+        }

+    }

+

+    return 0;

+}

new file mode 100644

@@ -0,0 +1,51 @@

+// Copyright 2024 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.

+

+//go:build darwin && !ios && cgo

+

+package prometheus

+

+/*

+int get_memory_info(unsigned long long *rss, unsigned long long *vs);

+*/

+import "C"

+import "fmt"

+

+func getMemory() (*memoryInfo, error) {

+	var rss, vsize C.ulonglong

+

+	if err := C.get_memory_info(&rss, &vsize); err != 0 {

+		return nil, fmt.Errorf("task_info() failed with 0x%x", int(err))

+	}

+

+	return &memoryInfo{vsize: uint64(vsize), rss: uint64(rss)}, nil

+}

+

+// describe returns all descriptions of the collector for Darwin.