* under the License.
 */
package org.apache.maven.execution;

import org.apache.maven.lifecycle.LifecycleExecutionException;

/**
 * <p>
 * Extension point that allows build extensions observe and possibly veto project build execution.
 * </p>
 * <strong>Note:</strong> This interface is part of work in progress and can be changed or removed without notice.
 *
 * @see ExecutionListener
 * @see MojoExecutionListener

func RecordRequestLatency(ctx context.Context, code string, latency float64) {
	requestLatency.WithContext(ctx).WithLabelValues(code).Observe(latency)

	// In pinSlow we store to local and then to localSize, here we load in opposite order.
	// Since we've disabled preemption, GC cannot happen in between.
	// Thus here we must observe local at least as large localSize.
	// We can observe a newer/larger local, it is fine (we must observe its zero-initialized-ness).
	s := runtime_LoadAcquintptr(&p.localSize) // load-acquire
	l := p.local                              // load-consume
	if uintptr(pid) < s {

			imageSize := int64(dp[0])
			duration := dp[1]
			t.Log(imageSize, duration)
			t.Log(GetImageSizeBucket(uint64(imageSize)))
			ImagePullDuration.WithLabelValues(GetImageSizeBucket(uint64(imageSize))).Observe(duration)
		}

		wants, err := os.Open("testdata/image_pull_duration_metric")
		defer func() {
			if err := wants.Close(); err != nil {
				t.Error(err)
			}
		}()

		if err != nil {
			t.Fatal(err)

type validationMetrics struct {
	RatchetingTime *metrics.Histogram
}

// ObserveRatchetingTime records the time spent on ratcheting
func (m *validationMetrics) ObserveRatchetingTime(d time.Duration) {
	m.RatchetingTime.Observe(d.Seconds())
}

// Reset resets the metrics. This is meant to be used for testing. Panics
// if the metrics cannot be re-registered. Returns all the reset metrics
func (m *validationMetrics) Reset() []metrics.Registerable {

	}

	if t.version >= 1 {
		options = append(options, cel.Function("test",
			cel.Overload("test", []*cel.Type{}, cel.BoolType,
				cel.FunctionBinding(func(args ...ref.Val) ref.Val {
					// Return false here so tests can observe which version of the function is registered
					// Actual function libraries must not break backward compatibility
					return types.False
				}))))
		options = append(options, cel.Function("testV1",

 */
package org.apache.maven.execution.scope;

import org.apache.maven.execution.MojoExecutionEvent;
import org.apache.maven.plugin.MojoExecutionException;

/**
 * Extension point that allows build extensions observe and possibly veto mojo executions.
 * <p>
 * Unlike {@link org.apache.maven.execution.MojoExecutionListener}, this extension point does not

	}

	// Once we close the profbuf, we'll be in one of two situations:
	// - The logger goroutine has already exited because it observed
	//   that the trace is disabled.
	// - The logger goroutine is asleep.
	//
	// Wake the goroutine so it can observe that their the buffer is
	// closed an exit.
	trace.cpuLogWrite[0].Store(nil)
	trace.cpuLogWrite[1].Store(nil)
	trace.cpuLogRead[0].close()

	code := "500"
	if err == nil {
		code = "200"
	} else if se, ok := err.(*apierrors.StatusError); ok && se.Status().Code != 0 {
		code = strconv.Itoa(int(se.Status().Code))
	}
	syncLatency.WithLabelValues(code).Observe(time.Since(start).Seconds())
	syncCounter.WithLabelValues(code).Inc()
}

var once sync.Once

func registerMetrics() {
	once.Do(func() {
		legacyregistry.MustRegister(syncCounter)

      float_type_observed = true;
    } else if (IsQI8Type(input_type)) {
      int8_type_observed = true;
    } else if (IsQUI8Type(input_type)) {
      uint8_type_observed = true;
    }
  }

  // We should not observe both uint8 & int8.
  if (int8_type_observed && uint8_type_observed) return UNKNOWN;

  if (float_type_observed) {
    if (int8_type_observed || uint8_type_observed) {
      return HYBRID;
    } else {