func TestZipkinTraceReporterFactory(t *testing.T) {
	ch, err := tchannel.NewChannel("svc", &tchannel.ChannelOptions{
		TraceReporterFactory: ZipkinTraceReporterFactory,
	})
	assert.NoError(t, err)

	// Create a TCollector channel, and add it as a peer to ch so Report works.
	mockServer := new(mocks.TChanTCollector)
	tcollectorCh, err := setupServer(mockServer)
	require.NoError(t, err, "setupServer failed")
	ch.Peers().Add(tcollectorCh.PeerInfo().HostPort)

	called := make(chan int)
	ret := &gen.Response{Ok: true}
	mockServer.On("Submit", mock.Anything, mock.Anything).Return(ret, nil).Run(func(args mock.Arguments) {
		called <- 1
	})

	// Make some calls, and validate that the trace reporter is not called recursively.
	require.NoError(t, json.Register(tcollectorCh, json.Handlers{"op": func(ctx json.Context, arg map[string]interface{}) (map[string]interface{}, error) {
		return arg, nil
	}}, nil), "Register failed")
	ctx, cancel := json.NewContext(time.Second)
	defer cancel()
	for i := 0; i < 5; i++ {
		var res map[string]string
		assert.NoError(t, json.CallSC(ctx, ch.GetSubChannel(tcollectorServiceName), "op", nil, &res), "call failed")
	}

	// Verify the spans being reported.
	for i := 0; i < 5; i++ {
		select {
		case <-called:
		case <-time.After(time.Second):
			t.Errorf("Expected submit for call %v", i)
		}
	}

	// Verify that no other spans are reported.
	select {
	case <-called:
		t.Errorf("Too many spans reported")
	case <-time.After(time.Millisecond):
	}
}
Beispiel #2
0
func (c *Client) sendAdvertise() error {
	// Cannot advertise from an ephemeral peer.
	if c.tchan.PeerInfo().IsEphemeral() {
		return errEphemeralPeer
	}

	ctx, cancel := json.NewContext(c.opts.Timeout)
	defer cancel()

	// Disable tracing on Hyperbahn advertise messages to avoid cascading failures (see #790).
	tchannel.CurrentSpan(ctx).EnableTracing(false)

	sc := c.tchan.GetSubChannel(hyperbahnServiceName)
	arg := c.createRequest()
	var resp AdResponse
	c.opts.Handler.On(SendAdvertise)

	if err := json.CallSC(ctx, sc, "ad", arg, &resp); err != nil {
		return err
	}

	return nil
}