// limitations under the License.

package monitoring_test

import "istio.io/istio/pkg/monitoring"

var (
	protocol = monitoring.CreateLabel("protocol")

	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

						Value: true,
					},
				}},

				Providers: []*tpb.ProviderRef{{Name: "prometheus"}},
			},
		},
	}
	cfg := `{"metrics":[{"dimensions":{"add":"bar"},"name":"requests_total","tags_to_remove":["remove"]}]}`

	tests := []struct {
		name             string
		cfgs             []config.Config
		proxy            *Proxy
		class            networking.ListenerClass

				}
			}
		default:
			// Only prometheus and SD supported currently
			continue
		}
	}
	return res
}

var metricToPrometheusMetric = map[string]string{
	"REQUEST_COUNT":          "requests_total",
	"REQUEST_DURATION":       "request_duration_milliseconds",
	"REQUEST_SIZE":           "request_bytes",
	"RESPONSE_SIZE":          "response_bytes",
	"TCP_OPENED_CONNECTIONS": "tcp_connections_opened_total",

	metricsTotal := int64(0)
	requestsTotal := int64(0)
	numEntries := 0

	for podName, metric := range metrics {
		request, hasRequest := requests[podName]
		if !hasRequest {
			// we check for missing requests elsewhere, so assuming missing requests == extraneous metrics
			continue
		}

		metricsTotal += metric.Value
		requestsTotal += request
		numEntries++
	}

			StabilityLevel: compbasemetrics.ALPHA,
		},
		[]string{"code"},
	)

	metrics = registerables{
		requestTotal,
		requestLatency,
	}
)

// RecordRequestTotal increments the total number of requests for the delegated authentication.
func RecordRequestTotal(ctx context.Context, code string) {
	requestTotal.WithContext(ctx).WithLabelValues(code).Inc()
}

)

var registerMetrics sync.Once

// RegisterMetrics registers authorizer metrics.
func RegisterMetrics() {
	registerMetrics.Do(func() {
		legacyregistry.MustRegister(requestTotal)
		legacyregistry.MustRegister(requestLatency)
	})
}

var (
	requestTotal = compbasemetrics.NewCounterVec(
		&compbasemetrics.CounterOpts{
			Name:           "apiserver_delegated_authz_request_total",

				return
			}
			defer server.Close()

			fakeAuthnMetrics := &fakeAuthenticatorMetrics{}
			authnMetrics := AuthenticatorMetrics{
				RecordRequestTotal:   fakeAuthnMetrics.RequestTotal,
				RecordRequestLatency: fakeAuthnMetrics.RequestLatency,
			}
			wh, err := newV1TokenAuthenticator(server.URL, scenario.clientCert, scenario.clientKey, scenario.clientCA, 0, nil, authnMetrics)
			if err != nil {

		},
		[]string{"status"},
	)
	requestCount = metrics.NewCounterVec(
		&metrics.CounterOpts{
			Namespace:      "authentication",
			Subsystem:      "token_cache",
			Name:           "request_total",
			StabilityLevel: metrics.ALPHA,
		},
		[]string{"status"},
	)
	fetchCount = metrics.NewCounterVec(
		&metrics.CounterOpts{
			Namespace:      "authentication",
			Subsystem:      "token_cache",

	RecordRequestLatency func(ctx context.Context, code string, latency float64)
}

type noopMetrics struct{}

func (noopMetrics) RequestTotal(context.Context, string)            {}

	if err != nil {
		return nil, err
	}
	return newWithBackoff(tokenReview, retryBackoff, implicitAuds, time.Duration(0), AuthenticatorMetrics{
		RecordRequestTotal:   noopMetrics{}.RequestTotal,
		RecordRequestLatency: noopMetrics{}.RequestLatency,
	})
}

// newWithBackoff allows tests to skip the sleep.