# Please keep entries ordered by code.
# NOTE: The range 0000-0100 is reserved for internal and/or future use.
messages:
  - name: "InternalError"
    code: IST0001
    level: Error
    description: "There was an internal error in the toolchain. This is almost always a bug in the implementation."
    template: "Internal error: %v"
    args:
      - name: detail
        type: string

  - name: "Deprecated"
    code: IST0002
    level: Warning

	}
	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)
			}
		}
	}

    def "each outgoing message is dispatched in order to connection"() {
        def messages = new CopyOnWriteArrayList()
        RemoteConnection<InterHubMessage> outgoing = Mock()
        def connection = new MockOutgoingConnection(outgoing)

        given:
        outgoing.dispatch({ it instanceof ChannelMessage }) >> { ChannelMessage message ->
            messages.add(message.payload)
            if (messages.size() == 20) {

Alexander Zielenski <******@****.***> 1705543770 -0800

        then:
        def messages = models.left
        messages.size() == 2
        messages[0] == "It works from project :"
        messages[1] == "It works from project :a"
        def model = models.right
        model.size() == 2
        model[0].message == "It works from project :"
        model[1].message == "It works from project :a"

        and:

    }

    private String join(String message1, String message2) {
        String message = "";

        if (message1 != null && !message1.isEmpty()) {
            message = message1.trim();
        }

        if (message2 != null && !message2.isEmpty()) {
            if (message != null && !message.isEmpty()) {
                if (message.endsWith(".") || message.endsWith("!") || message.endsWith(":")) {

 * a greeting. The greeting is composed of a message and a suffix. The message is compiled into a support
 * library. The suffix is compiled directly into the processor. This makes it easy to test different incremental
 * change scenarios. The message can also be provided with the -Amessage processor argument.
 */
@CompileStatic
class HelperProcessorFixture extends AnnotationProcessorFixture {
    String message = "greetings"
    boolean writeResources

        0 * listener._

        when:
        output.text('line').println()

        then:
        1 * listener.onOutput({ it.spans[0].text == toNative('another line\n') })
        0 * listener._
    }

    def forwardsEachLineOfTextToListener() {
        when:
        output.text(toNative('message1\nmessage2')).println()

        then:

        RuntimeException failure2 = new RuntimeException('broken2')

        when:
        dispatch.dispatchFailed("message1", failure1)
        dispatch.dispatchFailed("message2", failure2)
        dispatch.stop()

        then:
        def e = thrown(DispatchException)
        e.cause == failure1
        1 * logger.error('broken2', failure2)
        0 * logger._
    }

                            if (message instanceof EndOfStream) {
                                boundedDispatch.endStream();
                                return;
                            }
                            if (message instanceof ChannelMessage) {
                                ChannelMessage channelMessage = (ChannelMessage) message;