apmongo and apmgin do not work when used together

[bck01215]

Describe the bug
Using apmmongo and apmgin does not allow mongo to send spans

To Reproduce
Steps to reproduce the behavior:

1. use gin to create handler
2. call mongo with gin context in handler

Expected behavior
Expect spans to generate from use

[6fears7]

As an example:

What I'd expect to work:

        // r = *gin.Engine
	r.GET("/myendpoint", func(c *gin.Context) {
		ctx := apm.ContextWithTransaction(c, tx) // type: context.Context
		result, tErr := GetMyEndpoint(ctx, mClient, filter, databaseSuffix)

Result:
{"level":"debug","time":"2024-02-02T16:56:13-05:00","message":"sent request with 6 transactions, 0 spans, 0 errors, 0 metricsets"}

What I've done as a workaround and found to work:

        // r = *gin.Engine
	r.GET("/myendpoint", func(c *gin.Context) {
	// manually start trace
		tx := apm.DefaultTracer.StartTransaction("GetMyEndpoint", "request")
		defer tx.End()
		ctx := apm.ContextWithTransaction(c, tx)
		result, tErr := GetMyEndpoint(ctx, mClient, filter, databaseSuffix) // type: context.Context

Result:
{"level":"debug","time":"2024-02-02T16:56:13-05:00","message":"sent request with 6 transactions, 762 spans, 0 errors, 0 metricsets"}

A previous solution (#585) said to use the .Request.Context() but I did not find this to work.

        // r = *gin.Engine
	r.GET("/myendpoint", func(c *gin.Context) {
		result, tErr := GetMyEndpoint(c.Request.Context(), mClient, filter, databaseSuffix)

Result:
{"level":"debug","time":"2024-02-02T16:56:13-05:00","message":"sent request with 6 transactions, 0 spans, 0 errors, 0 metricsets"}

I am going to do some more work to determine if there's something odd on my end, though figured it'd be worth sharing this data regarding the issue.

[dmathieu]

apmgin calls apmhttp to create the transaction, and then sets it as c.Request:

apm-agent-go/module/apmgin/middleware.go

Lines 74 to 76 in 538be9b

	tx, body, req := apmhttp.StartTransactionWithBody(m.tracer, requestName, c.Request)
	defer tx.End()
	c.Request = req

On its end, apmhttp, when creating the transaction, calls StartTransaction and sets the new context onto the request:

apm-agent-go/module/apmhttp/handler.go

Lines 131 to 138 in 538be9b

	func StartTransactionWithBody(tracer *apm.Tracer, name string, req *http.Request) (*apm.Transaction, *apm.BodyCapturer, *http.Request) {
	tx, req := StartTransaction(tracer, name, req)
	bc := tracer.CaptureHTTPRequestBody(req)
	if bc != nil {
	req = RequestWithContext(apm.ContextWithBodyCapturer(req.Context(), bc), req)
	}
	return tx, bc, req
	}

However, it seems that context is only being set if the request body is not nil.
That seems a bit weird. @axw do you know the reason for that?

@6fears7 could you try the last alternative (using c.Request.Context()) which should indeed be the right way to do this, but when the request has a non-nil body? (I'm not saying always having a body is a fix of course, this is just an attempt to confirm my investigation).

[6fears7]

I set up a frontend that submits a POST request to a fake endpoint called "/testgin" with a JSON body of {"gintest": "test"} // 'test' is the collection in Mongo:

On the backend, TestGin retrieves the document from Mongo based off the collectionName:

	r.POST("/testgin", func(c *gin.Context) {
                
                var reqBody map[string]interface{}
		if err := c.ShouldBindJSON(&reqBody); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		collectionName := reqBody["gintest"].(string)

		result, err := ginTester.TestGin(mClient, databaseSuffix, c.Request.Context(), collectionName)
		
		
// {"level":"debug","time":"2024-02-05T15:30:59-05:00","message":"sent request with 1 transaction, 0 spans, 0 errors, 0 metricsets"}

No dice.

[axw]

However, it seems that context is only being set if the request body is not nil.
That seems a bit weird. @axw do you know the reason for that?

StartTransactionWithBody calls StartTransaction, which adds the transaction to the context. The one you're referring to is just for the body capturer.