return &out
}

// WithLabels adds a key-value pairs to the labels in s. The key must be a string, while the value may be any type.
// It returns a copy of s, with the labels added.
// e.g. newScope := oldScope.WithLabels("foo", "bar", "baz", 123, "qux", 0.123)
func (s *Scope) WithLabels(kvlist ...any) *Scope {
	out := s.copy()
	if len(kvlist)%2 != 0 {

func DebugEnabled() bool {
	return defaultScope.DebugEnabled()
}

// WithLabels adds a key-value pairs to the labels in s. The key must be a string, while the value may be any type.
// It returns a copy of the default scope, with the labels added.
func WithLabels(kvlist ...any) *Scope {
	return defaultScope.WithLabels(kvlist...)

	defer t.Stop()
	t0 := time.Now()
	defer func() {
		if r {
			log.WithLabels("name", name, "time", time.Since(t0)).Debugf("sync complete")
		} else {
			log.WithLabels("name", name, "time", time.Since(t0)).Errorf("sync failed")
		}
	}()
	for _, col := range collections {
		for {
			select {
			case <-t.C:
				log.WithLabels("name", name, "time", time.Since(t0)).Debugf("waiting for sync...")
				continue

	return p.handleDeltaUpstream(ctx, con, xds)
}

func (p *XdsProxy) handleDeltaUpstream(ctx context.Context, con *ProxyConnection, xds discovery.AggregatedDiscoveryServiceClient) error {
	log := proxyLog.WithLabels("id", con.conID)
	deltaUpstream, err := xds.DeltaAggregatedResources(ctx,
		grpc.MaxCallRecvMsgSize(defaultClientMaxReceiveMessageSize))
	if err != nil {
		// Envoy logs errors again, so no need to log beyond debug level

		echo.HostnameField.Write(&body, hostname)
	}

	epLog.WithLabels("id", id).Infof("GRPC Response")
	return &proto.EchoResponse{Message: body.String()}, nil
}

func (h *EchoGrpcHandler) ForwardEcho(ctx context.Context, req *proto.ForwardEchoRequest) (*proto.ForwardEchoResponse, error) {
	id := uuid.New()
	l := epLog.WithLabels("url", req.Url, "id", id)
	l.Infof("ForwardEcho request")
	t0 := time.Now()

		return fmt.Errorf("round trip failed: %v", resp.Status)
	}
	log.WithLabels("host", r.Host, "remote", remoteID).Info("CONNECT established")
	go func() {
		defer conn.Close()
		defer resp.Body.Close()

		wg := sync.WaitGroup{}
		wg.Add(1)
		go func() {
			// handle upstream (hbone server) --> downstream (app)
			copyBuffered(conn, resp.Body, log.WithLabels("name", "body to conn"))
			wg.Done()
		}()

				epLog.Warn("UDP read failed: " + err.Error())
				return
			}

			id := uuid.New()
			epLog.WithLabels("remote", remote, "id", id).Infof("UDP Request")

			responseFields := s.getResponseFields(remote)
			if _, err := listener.WriteTo([]byte(responseFields), remote); err != nil {
				epLog.WithLabels("id", id).Warnf("UDP failed writing echo response: %v", err)
			}
		}
	}()

// limitations under the License.

package cache

import (
	"fmt"

	"istio.io/istio/pkg/log"
)

func resourceLog(resourceName string) *log.Scope {
	return cacheLog.WithLabels("resource", resourceName)
}

// cacheLogPrefix returns a unified log prefix.
func cacheLogPrefix(resourceName string) string {
	lPrefix := fmt.Sprintf("resource:%s", resourceName)
	return lPrefix

			}
		})
	}
}

func TestDefaultWithLabel(t *testing.T) {
	lines, err := captureStdout(func() {
		Configure(DefaultOptions())
		funcs.Store(funcs.Load().(patchTable))
		WithLabels("foo", "bar").WithLabels("baz", 123, "qux", 0.123).Error("Hello")

		_ = Sync()
	})
	if err != nil {
		t.Errorf("Got error '%v', expected success", err)
	}

	return c
}

func (c *Controller) Reconcile(key types.NamespacedName) error {
	name := key.Name
	whc := c.webhooks.Get(name, "")
	scope := scope.WithLabels("webhook", name)
	// Stop early if webhook is not present, rather than attempting (and failing) to reconcile permanently
	// If the webhook is later added a new reconciliation request will trigger it to update
	if whc == nil {