'Bytes ({{pod}})',
          |||
            sum by (pod) (
              rate(
                go_memstats_alloc_bytes_total{%(appLabels)s}
              [$__rate_interval])
            )
          |||
        ),
        self.query(
          'Objects ({{pod}})',
          |||
            sum by (pod) (
              rate(
                go_memstats_mallocs_total{%(appLabels)s}
              [$__rate_interval])

# This example shows how to use Istio local rate limiting with descriptors to limit by path. 
# This uses the base book-info demo and adds rate limiting by path, specifically rate limiting the product page
# to 10 requests per minute, and the overall fdqn will be able to accept 100 requests per minute. 
apiVersion: networking.istio.io/v1alpha3
kind: EnvoyFilter
metadata:
  name: filter-local-ratelimit-svc
  namespace: istio-system
spec:
  workloadSelector:

##################################################################################################
# Redis service and deployment
# Ratelimit service and deployment

# Note: a configmap is needed to make the rate limit deployment work properly, for example:
#
#  apiVersion: v1
#  kind: ConfigMap
#  metadata:
#    name: ratelimit-config
#  data:
#    config.yaml: |
#      domain: echo-ratelimit
#      descriptors:

John Zheng <******@****.***> 1615837852 +0800

	s.function = function
	switch function {
	case sha3_224:
		s.rate = 144
		s.outputLen = 28
	case sha3_256:
		s.rate = 136
		s.outputLen = 32
	case sha3_384:
		s.rate = 104
		s.outputLen = 48
	case sha3_512:
		s.rate = 72
		s.outputLen = 64
	case shake_128:
		s.rate = 168
		s.outputLen = 32
	case shake_256:
		s.rate = 136
		s.outputLen = 64
	default:
		panic("sha3: unrecognized function code")

	}
	written = len(p)

	for len(p) > 0 {
		if d.n == 0 && len(p) >= d.rate {
			// The fast path; absorb a full "rate" bytes of input and apply the permutation.
			xorIn(d, p[:d.rate])
			p = p[d.rate:]
			keccakF1600(&d.a)
		} else {
			// The slow path; buffer the input until we can fill the sponge, and then xor it in.
			todo := d.rate - d.n
			if todo > len(p) {
				todo = len(p)
			}

package grpc

import (
	"context"

	gotimerate "golang.org/x/time/rate"
	"k8s.io/klog/v2"

	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

var (
	ErrorLimitExceeded = status.Error(codes.ResourceExhausted, "rejected by rate limit")
)

// Limiter defines the interface to perform request rate limiting,

// license that can be found in the LICENSE file.

package foo_test

import (
	"fmt"
	"time"

	"golang.org/x/time/rate"
)

func Example() {
	fmt.Println("Hello, world!")
	// Output: Hello, world!
}

func ExampleLimiter() {
	// Uses fmt, time and rate.
	l := rate.NewLimiter(rate.Every(time.Second), 1)
	fmt.Println(l)

// which samples to collect, based on the desired average collection
// rate R. The probability of a sample of size S to appear in that
// profile is 1-exp(-S/R).
func scaleHeapSample(count, size, rate int64) (int64, int64) {
	if count == 0 || size == 0 {
		return 0, 0
	}

	if rate <= 1 {
		// if rate==1 all samples were collected so no adjustment is needed.
		// if rate<1 treat as unknown and skip scaling.
		return count, size
	}

	"context"
	"fmt"
	"sync"
)

// RateLimiter abstracts the rate limiter used by RateLimitedSafeWaitGroup.
// The implementation must be thread-safe.
type RateLimiter interface {
	Wait(ctx context.Context) error
}

// RateLimiterFactoryFunc is used by the RateLimitedSafeWaitGroup to create a new
// instance of a RateLimiter that will be used to rate limit the return rate