});

dashboard.new('Istio Control Plane Dashboard')
+ g.dashboard.withPanels(
  grid.makeGrid([
    row.new('Deployed Versions')
    + row.withPanels([
      panels.timeSeries.simple('Pilot Versions', queries.istioBuild, 'Version number of each running instance'),
    ]),
  ], panelHeight=5)
  + grid.makeGrid([
    row.new('Resource Usage')
    + row.withPanels([

  container: "istio-proxy",
  pod: "ztunnel-.*",
  component: "ztunnel",
  app: "ztunnel",
});

dashboard.new('Istio Ztunnel Dashboard')
+ g.dashboard.withPanels(
  grid.makeGrid([
    row.new('Process')
    + row.withPanels([
      panels.timeSeries.base('Ztunnel Versions', queries.istioBuild, 'Version number of each running instance'),

	if level > debugLevelThreshold {
		zl.l.WithLabels(keysAndVals...).Debug(trimNewline(msg))
	} else {
		zl.l.WithLabels(keysAndVals...).Info(trimNewline(msg))
	}
}

func (zl *zapLogger) Error(err error, msg string, keysAndVals ...any) {
	if zl.l.ErrorEnabled() {
		if err == nil {
			zl.l.WithLabels(keysAndVals...).Error(trimNewline(msg))
		} else {
			zl.l.WithLabels(keysAndVals...).Error(fmt.Sprintf("%v: %s", err.Error(), msg))

		keyVals = append(keyVals, fmt.Sprintf("%q:%q", k, v))
	}

	slices.Sort(keyVals)

	return "{" + strings.Join(keyVals, ", ") + "}"
}

// WithLabels returns a new [context.Context] with the given labels added.
// A label overwrites a prior label with the same key.
func WithLabels(ctx context.Context, labels LabelSet) context.Context {
	parentLabels := labelValue(ctx)
	childLabels := make(labelMap, len(parentLabels))

	s := RegisterScope(name, desc)
	s.SetOutputLevel(DebugLevel)

	lines, err := captureStdout(func() {
		Configure(DefaultOptions())
		funcs.Store(funcs.Load().(patchTable))
		s2 := s.WithLabels("foo", "bar").WithLabels("baz", 123, "qux", 0.123).WithLabels("foo", "override")
		s2.Debug("Hello")
		// s should be unmodified.
		s.Debug("Hello")

		_ = Sync()
	})
	if err != nil {

				return
			}

			id := uuid.New()
			epLog.WithLabels("remote", conn.RemoteAddr(), "id", id).Infof("TCP Request")

			done := make(chan struct{})
			go func() {
				s.echo(id, conn)
				close(done)
			}()

			go func() {
				select {
				case <-done:
					return
				case <-time.After(requestTimeout):
					epLog.WithLabels("id", id).Warnf("TCP forcing connection closed after request timeout")

	ctx := context.Background()
	labels := labelsSorted(ctx)
	if len(labels) != 0 {
		t.Errorf("labels on background context: want [], got %v ", labels)
	}

	// Add a single label.
	ctx = WithLabels(ctx, Labels("key", "value"))
	// Retrieve it with Label.
	v, ok := Label(ctx, "key")
	if !ok || v != "value" {
		t.Errorf(`Label(ctx, "key"): got %v, %v; want "value", ok`, v, ok)
	}
	gotLabels := labelsSorted(ctx)

			if err != nil {
				log.WithLabels("image", b).Warnf("base failed: %v", err)
				return
			}
			plat := v1.Platform{
				Architecture: b.arch,
				OS:           "linux",
			}
			bi, err := remote.Image(ref, remote.WithPlatform(plat), remote.WithProgress(CreateProgress(fmt.Sprintf("base %v", ref))))
			if err != nil {
				log.WithLabels("image", b).Warnf("base failed: %v", err)
				return
			}

				if !f {
					h.log.WithLabels("oKey", oKey).Errorf("invalid event, deletion of non-existent object")
					continue
				}
				e := Event[O]{
					Event: controllers.EventDelete,
					Old:   &oldRes,
				}
				events = append(events, e)
				delete(h.collectionState.outputs, oKey)
				if h.log.DebugEnabled() {
					h.log.WithLabels("res", oKey).Debugf("handled delete")
				}
			}

	go func() {
		// downstream (hbone client) <-- upstream (app)
		copyBuffered(w, dst, log.WithLabels("name", "dst to w"))
		err = r.Body.Close()
		if err != nil {
			log.Infof("connection to hbone client is not closed: %v", err)
		}
		wg.Done()
	}()
	// downstream (hbone client) --> upstream (app)
	copyBuffered(dst, r.Body, log.WithLabels("name", "body to dst"))
	wg.Wait()
	log.Infof("connection closed in %v", time.Since(t0))