t0 := time.Now()
			if err := next.task(stop); err != nil {
				// Startup error: terminate and return the error.
				shutdown()
				return err
			}
			runtime := time.Since(t0)
			log := log.WithLabels("name", next.name, "runtime", runtime)
			log.Debugf("started task")
			if runtime > time.Second {
				log.Warnf("slow startup task")
			}
		default:
			// We've drained all of the initial tasks.

		// don't return error here, as this is purely informational.
	}
	return retErr
}

func (s *meshDataplane) RemovePodFromMesh(ctx context.Context, pod *corev1.Pod) error {
	log := log.WithLabels("ns", pod.Namespace, "name", pod.Name)
	err := s.netServer.RemovePodFromMesh(ctx, pod)
	if err != nil {
		log.Errorf("failed to remove pod from mesh: %v", err)
		return err
	}

// The augmented label map will be set for the duration of the call to f
// and restored once f returns.
func Do(ctx context.Context, labels LabelSet, f func(context.Context)) {
	defer SetGoroutineLabels(ctx)
	ctx = WithLabels(ctx, labels)
	SetGoroutineLabels(ctx)
	f(ctx)

	for _, c := range cfg {
		// Right now model.Config is not a proto - until we change it, mcp.Resource.
		// This also helps migrating MCP users.

		b, err := config.PilotConfigToResource(&c)
		if err != nil {
			log.WithLabels("resource", c.NamespacedName()).Warnf("resource error: %v", err)
			continue
		}
		resp = append(resp, &discovery.Resource{
			Name:     c.Namespace + "/" + c.Name,
			Resource: protoconv.MessageToAny(b),
		})

		lbls = append(lbls, "action", e.Action)
	}
	if e.LikelyCause != "" {
		lbls = append(lbls, "likelyCause", e.LikelyCause)
	}
	if e.Err != nil {
		lbls = append(lbls, "err", e.Err.Error())
	}
	return s.WithLabels(lbls...)
}

func (e *Error) Error() string {
	if e == nil {
		return ""
	}
	return fmt.Sprintf("\tmoreInfo=%s impact=%s action=%s likelyCause=%s err=%v",
		e.MoreInfo, e.Impact, e.Action, e.LikelyCause, e.Err)

			if err == nil {
				inDev = ii.Name
			}
		}
		if attrs.OutDev != nil {
			ii, err := net.InterfaceByIndex(int(*attrs.OutDev))
			if err == nil {
				outDev = ii.Name
			}
		}
		iptablesTrace.WithLabels(
			"command", prefix,
			"uid", uid,
			"gid", gid,
			"inDev", inDev,
			"outDev", outDev,
			"src", src,
			"dst", dst,
		).Infof(comment)
		return 0
	}

	b.ensureObjectMetaApplyConfigurationExists()
	b.DeletionGracePeriodSeconds = &value
	return b
}

// WithLabels puts the entries into the Labels field in the declarative configuration
// and returns the receiver, so that objects can be build by chaining "With" function invocations.

	} else {
		// Otherwise get everything
		list = c.List()
	}
	list = slices.FilterInPlace(list, func(i T) bool {
		o := c.augment(i)
		return d.filter.Matches(o, true)
	})
	if log.DebugEnabled() {
		log.WithLabels(
			"parent", h.name(),
			"fetch", c.name(),
			"filter", d.filter,
			"size", len(list),
		).Debugf("Fetch")
	}
	return list

func upstreamErr(con *ProxyConnection, err error) {
	if istiogrpc.IsExpectedGRPCError(err) {
		proxyLog.WithLabels("id", con.conID).Debugf("upstream terminated with status %v", err)
		metrics.IstiodConnectionCancellations.Increment()
	} else {
		proxyLog.WithLabels("id", con.conID).Warnf("upstream terminated with unexpected error %v", err)
		metrics.IstiodConnectionErrors.Increment()
	}
	select {

	b.ensureObjectMetaApplyConfigurationExists()
	b.DeletionGracePeriodSeconds = &value
	return b
}

// WithLabels puts the entries into the Labels field in the declarative configuration
// and returns the receiver, so that objects can be build by chaining "With" function invocations.