}
	bs.mu.RUnlock()

	return traceInfo
}

func (bs *bootstrapTracer) Publish(ctx context.Context, trace *pubsub.PubSub[madmin.TraceInfo, madmin.TraceType]) {
	for _, bsEvent := range bs.Events() {
		if bsEvent.Message != "" {
			select {
			case <-ctx.Done():
			default:
				trace.Publish(bsEvent)
			}
		}
	}

		"Number of unsent messages in queue for target",
		targetID)
	auditTotalMessagesMD = NewCounterMD(auditTotalMessages,
		"Total number of messages sent since start",
		targetID)
)

// loadClusterAuditMetrics - `MetricsLoaderFn` for cluster audit
// such as failed messages and total messages.
func loadClusterAuditMetrics(_ context.Context, m MetricValues, c *metricsCache) error {
	audit := logger.CurrentStats()
	for id, st := range audit {

			t.Errorf("failed to read from client. %v", terr)
			return
		}
		received = string(b)
		if received != "message two\n" {
			t.Errorf(`server: expected: "message two\n", got: %v`, received)
			return
		}

		// Send a response.
		_, terr = io.WriteString(deadlineconn, "messages received\n")
		if terr != nil {
			t.Errorf("failed to write to client. %v", terr)
			return
		}
	}()

	c, err := net.Dial("tcp", serverAddr)

)

// TargetStats contains statistics for a target.
type TargetStats struct {
	// QueueLength is the queue length if any messages are queued.
	QueueLength int

	// TotalMessages is the total number of messages sent in the lifetime of the target
	TotalMessages int64

	// FailedMessages should log message count that failed to send.
	FailedMessages int64

						fmt.Fprintln(cmd.ErrOrStderr(), "\t", a)
					}
				}
				fmt.Fprintln(cmd.ErrOrStderr())
			}

			// Get messages for output
			outputMessages := result.Messages.SetDocRef("istioctl-analyze").FilterOutLowerThan(outputThreshold.Level)

			// Print all the messages to stdout in the specified format
			output, err := formatting.Print(outputMessages, msgOutputFormat, colorize)
			if err != nil {
				return err

	)

	msgs := diag.Messages{firstMsg, secondMsg}
	output, _ := Print(msgs, YAMLFormat, false)

	expectedOutput := `- code: B1
  documentationUrl: ` + url.ConfigAnalysis + `/b1/
  level: Error
  message: 'Explosion accident: the bubble is too big'
  origin: SoapBubble
- code: C1
  documentationUrl: ` + url.ConfigAnalysis + `/c1/
  level: Warning
  message: 'Collapse danger: the castle is too old'

	"google.golang.org/protobuf/proto"

	"istio.io/istio/pkg/util/protomarshal"
)

// MessageSlice allows us to marshal slices of protobuf messages like clusters/listeners/routes/endpoints correctly
type MessageSlice []proto.Message

// MarshalJSON handles marshaling of slices of proto messages
func (pSlice MessageSlice) MarshalJSON() ([]byte, error) {
	buffer := bytes.NewBufferString("[")
	sliceLength := len(pSlice)

	formatComment     = `'namespace' reflects current bucket/object list and 'access' reflects a journal of object operations, defaults to 'namespace'`
	queueDirComment   = `staging dir for undelivered messages e.g. '/home/events'`
	queueLimitComment = `maximum limit for undelivered messages, defaults to '100000'`
)

// Help template inputs for all notification targets
var (
	HelpWebhook = config.HelpKVS{
		config.HelpKV{
			Key:         target.WebhookEndpoint,

	}

	return nil
}

// Cancel - cancels the target.
// All queued messages are flushed and the function returns afterwards.
// All messages sent to the target after this function has been called will be dropped.
func (h *Target) Cancel() {
	atomic.StoreInt32(&h.status, statusClosed)
	h.storeCtxCancel()

	// Wait for messages to be sent...
	h.wg.Wait()

	// Set logch to nil and close it.

func printYAML(ms diag.Messages) (string, error) {
	yamlOutput, err := yaml.Marshal(ms)
	return string(yamlOutput), err
}

// Formatting options for Message
var (
	colorPrefixes = map[diag.Level]string{
		diag.Info:    "",           // no special color for info messages
		diag.Warning: "\033[33m",   // yellow
		diag.Error:   "\033[1;31m", // bold red
	}
)