workerProcessBuilder.enableJvmMemoryInfoPublishing(true);
        final WorkerProcess workerProcess = workerProcessBuilder.build();

        return new MultiRequestClient<IN, OUT>() {
            private Receiver receiver = new Receiver(getBaseName(), outputEventListener);
            private RequestProtocol requestProtocol;

            @Override
            public WorkerProcess start() {

// A type with a couple of inlinable, non-pointer-receiver methods
// that have params and local variables.
type A struct {
	s    string
	next *A
	prev *A
}

// Inlinable, value-received method with locals and parms.
func (a A) double(x string, y int) string {
	if y == 191 {
		a.s = ""
	}
	q := a.s + "a"
	r := a.s + "b"
	return q + r
}

// Inlinable, value-received method with locals and parms.

        return handler.getMethod() + " /" + handler.getPath();
    }

    void received() {
        lock.lock();
        try {
            received = true;
        } finally {
            lock.unlock();
        }
    }

    public boolean isReceived() {
        lock.lock();
        try {
            return received;
        } finally {
            lock.unlock();
        }
    }

```bash
kubectl apply -f otel.yaml -n istio-system
```

With the following configuration, otel-collector-contrib will create a grpc receiver on port `4317`, and output to stdout. You can find more details [here](https://github.com/open-telemetry/opentelemetry-collector-contrib).

```yaml
    receivers:
      otlp:
        protocols:
          grpc:
          http:
    processors:
      batch:
      attributes:

import (
	"sync"

	"istio.io/istio/pkg/cluster"
)

type ServiceHandler func(*Service, *Service, Event)

// Controller defines an event controller loop.  Proxy agent registers itself
// with the controller loop and receives notifications on changes to the
// service topology or changes to the configuration artifacts.
//
// The controller guarantees the following consistency requirement: registry

        0 * staleAddressDetector._
    }

    def "handles failed receive"() {
        def failure = new FooException()

        given:
        1 * delegate.receive() >> Stub(Message)
        delegate.receive() >> { throw failure }

        when:
        connection.receive()
        connection.receive()

        then:
        def ex = thrown(DaemonConnectionException)

	"sync"
	"testing"
	"time"
)

// Track calls to the managed function.
type receiver struct {
	lock    sync.Mutex
	run     bool
	retryFn func()
}

func (r *receiver) F() {
	r.lock.Lock()
	defer r.lock.Unlock()
	r.run = true

	if r.retryFn != nil {
		r.retryFn()
		r.retryFn = nil
	}
}

func (r *receiver) reset() bool {
	r.lock.Lock()
	defer r.lock.Unlock()
	was := r.run
	r.run = false

the receiver accepts the value and stores it in the destination variable.
Floating-point numbers are always sent using IEEE 754 64-bit precision (see
below).

Signed integers may be received into any signed integer variable: int, int16, etc.;
unsigned integers may be received into any unsigned integer variable; and floating
point values may be received into any floating point variable. However,

	// read from the client
	received := make([]byte, len(pf.expected[port]))
	n, err := stream.Read(received)
	if err != nil {
		return fmt.Errorf("error reading from client for port %d: %v", port, err)
	}
	if n != len(pf.expected[port]) {
		return fmt.Errorf("unexpected length read from client for port %d: got %d, expected %d. data=%q", port, n, len(pf.expected[port]), string(received))
	}

	// store the received content

     *
     * <p>The client application can receive objects sent using this method by registering a {@link StreamedValueListener}.
     * The client application receives objects in the order they were sent, and before it receives the result of the {@link BuildAction}.</p>
     *
     * <p>This method sends the object asynchronously and does not block until the client application has received the object.</p>
     *