Unable to display information in External calls panel

[FournyP]

Bug description

Hi everyone, I'm a newby so I have maybe make some mistakes
I face some issues to display external calls from my http client in Golang

I have follow the step 4 of this article : https://signoz.io/blog/distributed-tracing-golang/ without using gorilla/mux

My initTracer :

func initTracer(insecure bool, serviceName, collectorURL string) func(context.Context) error {
	secureOption := otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
	if insecure {
		secureOption = otlptracegrpc.WithInsecure()
	}

	exporter, err := otlptrace.New(
		context.Background(),
		otlptracegrpc.NewClient(
			secureOption,
			otlptracegrpc.WithEndpoint(collectorURL),
		),
	)

	if err != nil {
		log.Fatal(err)
	}
	resources, err := resource.New(
		context.Background(),
		resource.WithAttributes(
			attribute.String("service.name", serviceName),
			attribute.String("library.language", "go"),
		),
	)
	if err != nil {
		log.Printf("Could not set resources: ", err)
	}

	otel.SetTracerProvider(
		sdktrace.NewTracerProvider(
			sdktrace.WithSampler(sdktrace.AlwaysSample()),
			sdktrace.WithBatcher(exporter),
			sdktrace.WithResource(resources),
		),
	)
	return exporter.Shutdown
}

I have create my HttpClient like this :

func NewHttpClient() *http.Client {
	return &http.Client{
		Transport: otelhttp.NewTransport(http.DefaultTransport),
	}
}

And in my service, I use the same http client using google wire :

func NewPingExchangesUseCase(httpClient *http.Client, ...) *PingExchangesUseCase {
	return &PingExchangesUseCase{
		httpClient:            httpClient,
                ...
	}
}

And I use the httpClient like this :

func (pingUseCase *PingExchangesUseCase) Execute(message *PingExchangesMessage) ([]*PingExchangesResponse, error) {
        ...
	response, err := pingUseCase.httpClient.Get(path)
        ...
}

And nothing is display in the external calls panel.

There is js errors when I open the console (image below)

Expected behavior

Actual behavior

All responses are the same

Overview metrics and database calls work perfectly as you can see :

Do you know if it's a bug or I've done something wrong ?

Version information

• Signoz version: 0.11.4
• Browser version: Brave version 1.46.140 (Based on Chromium 108.0.5359.99)
• Your OS and version: Windows 11 using WSL with Ubuntu 20.04.2
• Your CPU Architecture(ARM/Intel): Intel(R) Core(TM) i7-8565U CPU @ 1.80GHz 1.99 GHz

Have a good day and thanks for your work !

[welcome]

Thanks for opening this issue. A team member should give feedback soon. In the meantime, feel free to check out the contributing guidelines.

[pranay01]

Thanks @FournyP for opening the issue. I am curious, how did you get the chart with External Calls having the expected behavior? Was it working for some time and then stopped working?

Also, can you share otel client library versions you are using

Here's more details on when calls should appear in external calls in SigNoz - https://signoz.io/docs/userguide/metrics/#external-calls

[srikanthccv]

@FournyP Can you share a reproducible example (with versions of SDK and instrumentation) where the external call metrics page doesn't show any data? I could not reproduce with the following program that uses Go SDK + HTTP instrumentation.

test snippet

package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"time"

	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
	"go.opentelemetry.io/otel/sdk/resource"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
	"google.golang.org/grpc/credentials"
)

func initTracer(insecure bool, serviceName, collectorURL string) func(context.Context) error {
	secureOption := otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
	if insecure {
		secureOption = otlptracegrpc.WithInsecure()
	}

	exporter, err := otlptrace.New(
		context.Background(),
		otlptracegrpc.NewClient(
			secureOption,
			otlptracegrpc.WithEndpoint(collectorURL),
		),
	)

	// stdoutExporter, err := stdouttrace.New(stdouttrace.WithPrettyPrint())
	// if err != nil {
	// 	log.Fatal(err)
	// }

	if err != nil {
		log.Fatal(err)
	}
	resources, err := resource.New(
		context.Background(),
		resource.WithAttributes(
			attribute.String("service.name", serviceName),
			attribute.String("library.language", "go"),
		),
	)
	if err != nil {
		log.Printf("Could not set resources: ", err)
	}

	otel.SetTracerProvider(
		sdktrace.NewTracerProvider(
			sdktrace.WithSampler(sdktrace.AlwaysSample()),
			sdktrace.WithBatcher(exporter),
			// sdktrace.WithBatcher(stdoutExporter),
			sdktrace.WithResource(resources),
		),
	)
	return exporter.Shutdown
}

func NewHttpClient() *http.Client {
	return &http.Client{
		Transport: otelhttp.NewTransport(http.DefaultTransport),
	}
}

func main() {
	defer initTracer(true, "test", "localhost:4317")(context.Background())
	client := NewHttpClient()
	for i := 0; i < 400; i++ {
		url := "http://example.com:80"
		if i%2 == 0 {
			url = "https://example.com:443"
		}
		resp, err := client.Get(url)
		if err != nil {
			log.Fatal(err)
		}
		resp.Body.Close()
		time.Sleep(1 * time.Second)

		fmt.Printf("\nResponse: %v\n", resp.StatusCode)
	}
}

[FournyP]

Hi @srikanthccv, I have test your code

It work when i can be over than 6, when I run this code using i < 4 nothing is display in signoz
Maybe it's the problem in my code because each request to my server throw only 2 requests

I'm gonna make a little poc and share it to you (I can't share the code source of the original solution)

Have a good day

[FournyP]

I have made a little POC, there is some files

main.go :

package main

import (
	"context"
)

func main() {
	app := InitializeApp()
	defer app.Cleanup(context.Background())

	app.FiberApp.Listen(":8000")
}

wire_gen.go :

// Code generated by Wire. DO NOT EDIT.

//go:generate go run github.com/google/wire/cmd/wire
//go:build !wireinject
// +build !wireinject

package main

import (
	"test/controllers"
	"test/usecases"
)

// Injectors from wire.go:

func InitializeApp() *App {
	httpClient := NewHttpClient()
	pingUseCase := usecases.NewPingUseCase(httpClient)
	pingController := controllers.NewPingController(pingUseCase)
	app := NewApp(pingController)
	return app
}

httpclient.go :

package main

import (
	"net/http"

	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
)

func NewHttpClient() *http.Client {
	return &http.Client{
		Transport: otelhttp.NewTransport(http.DefaultTransport),
	}
}

app.go :

package main

import (
	"context"
	"log"

	"test/controllers"

	"github.com/gofiber/contrib/otelfiber"
	"github.com/gofiber/fiber/v2"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
	"google.golang.org/grpc/credentials"

	"go.opentelemetry.io/otel/sdk/resource"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
)

type App struct {
	FiberApp *fiber.App
	Cleanup  func(context.Context) error
}

func initTracer(insecure bool, serviceName, collectorURL string) func(context.Context) error {
	secureOption := otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
	if insecure {
		secureOption = otlptracegrpc.WithInsecure()
	}

	exporter, err := otlptrace.New(
		context.Background(),
		otlptracegrpc.NewClient(
			secureOption,
			otlptracegrpc.WithEndpoint(collectorURL),
		),
	)

	if err != nil {
		log.Fatal(err)
	}
	resources, err := resource.New(
		context.Background(),
		resource.WithAttributes(
			attribute.String("service.name", serviceName),
			attribute.String("library.language", "go"),
		),
	)
	if err != nil {
		log.Printf("Could not set resources: ", err)
	}

	otel.SetTracerProvider(
		sdktrace.NewTracerProvider(
			sdktrace.WithSampler(sdktrace.AlwaysSample()),
			sdktrace.WithBatcher(exporter),
			sdktrace.WithResource(resources),
		),
	)
	return exporter.Shutdown
}

func NewApp(pingController *controllers.PingController) *App {

	cleanup := initTracer(true, "test1", "localhost:4317")

	fiberApp := fiber.New()

	fiberApp.Use(otelfiber.Middleware("test1"))

	// -------- PING CONTROLLER -------- //
	fiberApp.Get("/ping", pingController.Ping)

	return &App{
		FiberApp: fiberApp,
		Cleanup:  cleanup,
	}
}

controllers/pingcontroller.go :

package controllers

import (
	"fmt"

	"test/usecases"

	"github.com/gofiber/fiber/v2"
)

type PingController struct {
	pingUseCase *usecases.PingUseCase
}

func NewPingController(pingUseCase *usecases.PingUseCase) *PingController {
	return &PingController{
		pingUseCase: pingUseCase,
	}
}

func (controller *PingController) Ping(c *fiber.Ctx) error {
	c.Accepts("json", "text")

	pingMessage := new(usecases.PingMessage)

	if err := c.QueryParser(pingMessage); err != nil {
		return fmt.Errorf("invalid format : %v", err)
	}

	response, err := controller.pingUseCase.Execute(pingMessage)

	if err != nil {
		return err
	}

	return c.JSON(response)
}

usecases/pingusecase.go :

package usecases

import (
	"fmt"
	"net/http"

	"test/utils"

	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
)

type PingMessage struct {
	Websites []string `query:"websites"`
}

type PingResponse struct {
	Website string
	Result  string
}

type PingUseCase struct {
	httpClient *http.Client
}

func NewPingUseCase(httpClient *http.Client) *PingUseCase {
	return &PingUseCase{
		httpClient: httpClient,
	}
}

func (pingUseCase *PingUseCase) Execute(message *PingMessage) ([]interface{}, error) {
	errors := make(chan error)
	defer close(errors)

	results := make(chan interface{})
	defer close(results)

	pingUseCase.httpClient.Transport = otelhttp.NewTransport(http.DefaultTransport)

	for _, website := range message.Websites {
		go func(url string) {
			response, err := pingUseCase.httpClient.Get(url)

			if err != nil {
				errors <- fmt.Errorf("error requesting %v", url)
			}

			results <- PingResponse{
				Website: url,
				Result:  response.Status,
			}
		}(website)
	}

	responses, err := utils.HandleRoutines(results, errors, len(message.Websites))

	if err != nil {
		return nil, err
	}

	return responses, nil
}

utils/usecasesutils.go :

package utils

func HandleRoutines(results chan interface{}, errors chan error, waitedResponse int) ([]interface{}, error) {
	var responses []interface{}
	var errs []error

	for {
		select {
		case result := <-results:
			responses = append(responses, result)
		case err := <-errors:
			errs = append(errs, err)
		}

		if len(responses)+len(errs) == waitedResponse {
			break
		}
	}

	return responses, CombineErrors(errs)
}

utils/errorsutils.go :

package utils

import "fmt"

func CombineErrors(errors []error) error {
	if len(errors) == 0 {
		return nil
	}

	var combinedError string
	for _, err := range errors {
		combinedError += err.Error() + "\n"
	}

	return fmt.Errorf(combinedError)
}

It's a simplified version of our api without database connection
This code seem work better than our solution in SigNoz but not all http call are display

I call my api using this :

So, as you can see, my endpoint call https://google.com and https://github.com simultaneously but only one is display in signoz

https://github.com is not reported

In our original solution, none of our call was reported

Have a good day and thanks for your work !

[srikanthccv]

@FournyP I tried it again with <6, and it still works, although one needs to run it more than once, so there is enough data for minute interval aggregation. If you could share a simple git repo URL with reproducible steps rather than the multiple numbers of partial go files, that would help debug the issue. How many calls does your server make to external URLs in a minute/hour?

[FournyP]

Hi @srikanthccv ,

You can use this github repository : https://github.com/FournyP/opentelemetry-example

And use the following curl command :

curl --location -g --request GET 'http://127.0.0.1:8000/ping?websites[]=https://google.com&websites[]=https://github.com'

In signoz, only the google call will be listed in "External call" panel as you can see :

Have a good day and happy new year !

[srikanthccv]

Thanks, I will take a look.

[FournyP]

Hi everyone

Any news ?