if m.latenciesSummary != nil {
		m.latenciesSummary.Reset()
	}
}

// Observe records an observed admission event to all metrics in the metricSet.
func (m *metricSet) observe(ctx context.Context, elapsed time.Duration, labels ...string) {
	elapsedSeconds := elapsed.Seconds()
	m.latencies.WithContext(ctx).WithLabelValues(labels...).Observe(elapsedSeconds)
	if m.latenciesSummary != nil {

	m.policyCheck.WithContext(ctx).WithLabelValues(policy, binding, "allow", state).Inc()
	m.policyLatency.WithContext(ctx).WithLabelValues(policy, binding, "allow", state).Observe(elapsed.Seconds())
}

// ObserveRejection observes a policy validation error that was at least one of the reasons for a deny.

package atomic

// LoadAcquire is a partially unsynchronized version
// of Load that relaxes ordering constraints. Other threads
// may observe operations that precede this operation to
// occur after it, but no operation that occurs after it
// on this thread can be observed to occur before it.
//
// WARNING: Use sparingly and with great care.
//
//go:nosplit
func (u *Uint64) LoadAcquire() uint64 {

}

// ObserveReconciliationResult observes some metrics from a reconciliation result.
func (r *monitor) ObserveReconciliationResult(action ActionLabel, err ErrorLabel, duration time.Duration) {
	reconciliationsTotal.WithLabelValues(string(action), string(err)).Inc()
	reconciliationsDuration.WithLabelValues(string(action), string(err)).Observe(duration.Seconds())
}

// ObserveMetricComputationResult observes some metrics from a metric computation result.

		"apiserver_validating_admission_policy_check_total",
		"apiserver_validating_admission_policy_check_duration_seconds",
	}

	testCases := []struct {
		desc     string
		want     string
		observer metricsObserver
	}{
		{
			desc: "observe policy admission",
			want: `

<p>
A read <i>r</i> of a memory location <i>x</i>
holding a value
that is not larger than a machine word must observe
some write <i>w</i> such that <i>r</i> does not happen before <i>w</i>
and there is no write <i>w'</i> such that <i>w</i> happens before <i>w'</i>
and <i>w'</i> happens before <i>r</i>.
That is, each read must observe a value written by a preceding or concurrent write.
</p>

<p>

	}
	_, err := meter().Float64ObservableGauge(name,
		api.WithDescription(description),
		api.WithFloat64Callback(func(ctx context.Context, observer api.Float64Observer) error {
			dm.mu.RLock()
			defer dm.mu.RUnlock()
			for kv, compute := range dm.attrs {
				observer.Observe(compute(), api.WithAttributeSet(kv))
			}
			return nil
		}))
	if err != nil {
		log.Fatalf("failed to create derived gauge: %v", err)
	}

			"observedRunningTime", state.observedRunningTime,
			"watchObservedRunningTime", when)

		metrics.PodStartSLIDuration.WithLabelValues().Observe(podStartSLOduration)
		metrics.PodStartTotalDuration.WithLabelValues().Observe(podStartingDuration.Seconds())
		state.metricRecorded = true
		// if is the first Pod with network track the start values

					err = r.(error)
				}
			}()
			fs.Parse(strings.Split(tc.argc, " "))
		}()

		if tc.expectErr && err == nil {
			t.Errorf("did not observe an expected error")
			continue
		}
		if !tc.expectErr && err != nil {
			t.Errorf("observed an unexpected error: %v", err)
			continue
		}
		if tc.expectVal != ip {
			t.Errorf("unexpected ip: expected %q, saw %q", tc.expectVal, ip)
		}
	}
}

	g, err := meter().Float64ObservableGauge(o.name,
		api.WithFloat64Callback(func(ctx context.Context, observer api.Float64Observer) error {
			r.attributeSetsMutex.Lock()
			defer r.attributeSetsMutex.Unlock()
			for _, gv := range r.attributeSets {
				observer.Observe(gv.val, gv.opt...)
			}
			return nil
		}),
		api.WithDescription(o.description),
		api.WithUnit(string(o.unit)))
	if err != nil {