requests = monitoring.NewSum(
		"requests_total",
		"Number of requests handled, by protocol",
	)
)

func ExampleNewSum() {
	// increment on every http request
	requests.With(protocol.Value("http")).Increment()

	// count gRPC requests double
	requests.With(protocol.Value("grpc")).Record(2)

func (s *Server) CreateCertificate(ctx context.Context, request *pb.IstioCertificateRequest) (
	*pb.IstioCertificateResponse, error,
) {
	s.monitoring.CSR.Increment()
	caller, err := security.Authenticate(ctx, s.Authenticators)
	if caller == nil || err != nil {
		s.monitoring.AuthnError.Increment()
		return nil, status.Error(codes.Unauthenticated, "request authenticate failure")
	}

    }

    // Set the increment to 256 * delta.
    Type u64 = rewriter.getIntegerType(64, /*isSigned=*/false);
    RankedTensorType u64_scalar = RankedTensorType::get({}, u64);
    Value step_size = rewriter.create<ConstOp>(loc, GetScalarOfType(u64, 256));
    Value increment =
        rewriter.create<MulOp>(loc, u64_scalar, step_size, rng_op.getDelta());

    // Increment the counter.
    SmallVector<Value, 4> pack_args;

// Instead, we can wrap the backoff hook to log/increment metrics before returning the backoff result.
func wrapBackoffWithMetrics(bf retry.BackoffFunc) retry.BackoffFunc {
	return func(attempt uint) time.Duration {
		wait := bf(attempt)
		caLog.Warnf("ca request failed, starting attempt %d in %v", attempt, wait)
		monitoring.NumOutgoingRetries.With(monitoring.RequestType.Value(monitoring.CSR)).Increment()
		return wait
	}

	manager.SetGroups(apis.Items)

	interests := []string{"aggregator_discovery_aggregation_count_total"}

	_, _, _ = fetchPath(manager, "application/json", discoveryPath, "")
	// A single fetch should aggregate and increment regeneration counter.
	if err := testutil.GatherAndCompare(legacyregistry.DefaultGatherer, formatExpectedMetrics(1), interests...); err != nil {
		t.Fatal(err)
	}

// errorcheck -0 -d=ssa/prove/debug=1

//go:build amd64

package main

func invert(b func(), n int) {
	for i := 0; i < n; i++ { // ERROR "(Inverted loop iteration|Induction variable: limits \[0,\?\), increment 1)"
		b()
	}

// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build cmd_go_bootstrap

package telemetrystats

		m.expMovingAvg = float64(bytesSinceLastWindow) / duration.Seconds()
		return
	}

	increment := float64(bytesSinceLastWindow) / duration.Seconds()
	m.expMovingAvg = exponentialMovingAverage(betaBucket, m.expMovingAvg, increment)
}

// exponentialMovingAverage calculates the exponential moving average
func exponentialMovingAverage(beta, previousAvg, incrementAvg float64) float64 {

	i, val := 0, atomic.LoadUint64(&a)
	for ; val == 0 && i < 100; val, i = atomic.LoadUint64(&a), i+1 {
		time.Sleep(100 * time.Millisecond)
	}
	if val == 0 {
		fmt.Printf("Failed to observe atomic increment after %d tries\n", i)
	}

	"provider_lookup_cluster_failures",
	"Number of times a cluster lookup failed",
)

func IncLookupClusterFailures(provider string) {
	providerLookupClusterFailures.With(typeTag.Value(provider)).Increment()