return LabelValue{e}
		})
		rh.OnRecord(f.name, lv, value)
	}
	recordHookMutex.RUnlock()
}

func (f baseMetric) Register() error {
	return nil
}

func (f baseMetric) RecordInt(value int64) {
	f.rest.Record(float64(value))
}

func rebuildAttributes(bm baseMetric, labelValues []LabelValue) ([]attribute.KeyValue, attribute.Set) {
	attrs := make([]attribute.KeyValue, 0, len(bm.attrs)+len(labelValues))

import kotlin.reflect.KProperty


/**
 * Maintains the current state of the build configuration input tracking.
 * Input tracking may be disabled for a particular thread to avoid recording inputs that doesn't
 * directly affect the configuration.
 * For example, accessing environment variable inside the `ValueSource` being obtained at

import java.util.Set;

public class DefaultMultipleCandidateResult<T> implements MultipleCandidatesResult<T> {
    private final Set<T> candidateValues;
    private final T consumerValue;

    // Match recording is optimized for the general case of a single match
    private T singleMatch;
    private Set<T> multipleMatches;

    public DefaultMultipleCandidateResult(@Nullable T consumerValue, Set<T> candidateValues) {

     */
    Optional<Throwable> getDisabledReason(String repositoryId);

    /**
     * Attempts to disable the repository with the given id, recording the exception causing it to be disabled, if
     * that exception is deemed critical.
     *
     * @param repositoryId the id of the repository to disable
     * @param throwable the reason why the repository is being disabled

   * AssertionFailedError thrown, so that the current testcase will fail.
   */
  public void threadAssertFalse(boolean b) {
    try {
      assertFalse(b);
    } catch (AssertionFailedError t) {
      threadRecordFailure(t);
      throw t;
    }
  }

  /**
   * Just like assertNull(x), but additionally recording (using threadRecordFailure) any

stdout 'rsc\.io/quote v1\.0\.0 .* v1\.5\.3-pre1$'
! stderr .

# Incidentally fetching the required version of a module records its checksum,
# just because it happens to be in the build list, and recording the checksum
# triggers an error under -mod=readonly.
#
# TODO(#41297): This should not be an error.
! go list -m -mod=readonly rsc.io/quote@<v1.5.2
stderr '^go: updates to go.sum needed, disabled by -mod=readonly$'

   * AssertionFailedError thrown, so that the current testcase will fail.
   */
  public void threadAssertFalse(boolean b) {
    try {
      assertFalse(b);
    } catch (AssertionFailedError t) {
      threadRecordFailure(t);
      throw t;
    }
  }

  /**
   * Just like assertNull(x), but additionally recording (using threadRecordFailure) any

	"io"
)

// RequestRecorder - records the
// of a given io.Reader
type RequestRecorder struct {
	// Data source to record
	io.Reader
	// Response body should be logged
	LogBody bool

	// internal recording buffer
	buf bytes.Buffer
	// total bytes read including header size
	bytesRead int
}

// Close is a no operation closer
func (r *RequestRecorder) Close() error {
	// no-op
	return nil
}

// The key type is unexported to prevent collisions
type key int

const (
	// warningRecorderKey is the context key for the warning recorder.
	warningRecorderKey key = iota
)

// Recorder provides a method for recording warnings
type Recorder interface {
	// AddWarning adds the specified warning to the response.
	// agent must be valid UTF-8, and must not contain spaces, quotes, backslashes, or control characters.

  /**
   * Returns a current snapshot of this cache's cumulative statistics, or a set of default values if
   * the cache is not recording statistics. All statistics begin at zero and never decrease over the
   * lifetime of the cache.
   *
   * <p><b>Warning:</b> this cache may not be recording statistical data. For example, a cache
   * created using {@link CacheBuilder} only does so if the {@link CacheBuilder#recordStats} method