if race.Enabled {
		if delta < 0 {
			// Synchronize decrements with Wait.
			race.ReleaseMerge(unsafe.Pointer(wg))
		}
		race.Disable()
		defer race.Enable()
	}
	state := wg.state.Add(uint64(delta) << 32)
	v := int32(state >> 32)
	w := uint32(state)
	if race.Enabled && delta > 0 && v == int32(delta) {
		// The first increment must be synchronized with Wait.
		// Need to model this as a read, because there can be

	totalXDSRejects.With(typeTag.Value(model.GetMetricType(xdsType))).Increment()
	switch xdsType {
	case model.ListenerType:
		ldsReject.With(nodeTag.Value(node), errTag.Value(errCode)).Increment()
	case model.ClusterType:
		cdsReject.With(nodeTag.Value(node), errTag.Value(errCode)).Increment()
	case model.EndpointType:
		edsReject.With(nodeTag.Value(node), errTag.Value(errCode)).Increment()
	case model.RouteType:

    checkArgument(autoIncrementStep >= 0, "May not auto-increment by a negative amount");
    this.autoIncrementStepNanos = timeUnit.toNanos(autoIncrementStep);
    return this;
  }

  /**
   * Sets the increment applied to the ticker whenever it is queried.
   *
   * <p>The default behavior is to auto increment by zero. i.e: The ticker is left unchanged when
   * queried.
   *
   * @since 28.0

func reportWebhookPatchAttempts(webhookConfigName string) {
	metricWebhookPatchAttempts.
		With(webhookConfigNameTag.Value(webhookConfigName)).
		Increment()
}

func reportWebhookPatchRetry(webhookConfigName string) {
	metricWebhookPatchRetries.
		With(webhookConfigNameTag.Value(webhookConfigName)).
		Increment()
}

func reportWebhookPatchFailure(webhookConfigName string, reason string) {
	metricWebhookPatchFailures.

	metricWebhookConfigurationUpdateError.With(reasonLabel.Value(string(reason))).Increment()
}

func reportValidationConfigLoadError(reason string) {
	metricWebhookConfigurationLoadError.With(reasonLabel.Value(reason)).Increment()
}

func reportValidationConfigUpdate() {
	metricWebhookConfigurationUpdates.Increment()

		// TODO use a single metric with a type tag
		switch xdsType {
		case v3.ListenerType:
			ldsSendErrPushes.Increment()
		case v3.ClusterType:
			cdsSendErrPushes.Increment()
		case v3.EndpointType:
			edsSendErrPushes.Increment()
		case v3.RouteType:
			rdsSendErrPushes.Increment()
		}
		return true
	}
	return false
}

func recordPushTime(xdsType string, duration time.Duration) {

		old           *unstructured.Unstructured
		obj           *unstructured.Unstructured
		statusEnabled bool
		expected      *unstructured.Unstructured
	}{
		{
			name:          "/status is enabled, spec changes increment generation",
			statusEnabled: true,
			old: &unstructured.Unstructured{
				Object: map[string]interface{}{
					"metadata": generation1(),
					"spec":     "old",
					"status":   "old",
				},
			},

    checkArgument(autoIncrementStep >= 0, "May not auto-increment by a negative amount");
    this.autoIncrementStepNanos = timeUnit.toNanos(autoIncrementStep);
    return this;
  }

  /**
   * Sets the increment applied to the ticker whenever it is queried.
   *
   * <p>The default behavior is to auto increment by zero. i.e: The ticker is left unchanged when
   * queried.
   *

        void increment(PluginApplication pluginApplication, long duration) {
            InternalPluginIdentifier plugin = pluginApplication.getPlugin();
            pluginApplicationResults
                .computeIfAbsent(plugin, key -> new PluginApplicationResult(plugin, pluginApplication.getApplicationId()))
                .increment(duration);
        }

		With(ResourceTag.Value(request.Resource.Resource)).
		With(ReasonTag.Value(reason)).
		Increment()
}

func reportValidationPass(request *kube.AdmissionRequest) {
	metricValidationPassed.
		With(GroupTag.Value(request.Resource.Group)).
		With(VersionTag.Value(request.Resource.Version)).
		With(ResourceTag.Value(request.Resource.Resource)).
		Increment()
}

func reportValidationHTTPError(status int) {
	metricValidationHTTPError.