Merge pull request #768 from Abdulsametileri/main

feat: propagate newrelic tx info by using fiber.Ctx and little refact…

fibernewrelic/README.md

@@ -90,9 +90,19 @@ func main() {
 	app.Get("/", func(ctx *fiber.Ctx) error {
 		return ctx.SendStatus(200)
 	})
+
+	app.Get("/foo", func(ctx *fiber.Ctx) error {
+		txn := newrelic.FromContext(ctx)
+		segment := txn.StartSegment("foo segment")
+		defer segment.End()
+
+		// do foo 
+
+		return nil
+	})
 
 	cfg := fibernewrelic.Config{
-		Application:       newrelicApp
+		Application:       newrelicApp,
 	}
 
 	app.Use(fibernewrelic.New(cfg))

fibernewrelic/fiber.go

@@ -2,11 +2,11 @@ package fibernewrelic
 
 import (
 	"fmt"
+	"github.com/gofiber/fiber/v2/utils"
 	"net/url"
 	"strings"
 
 	"github.com/gofiber/fiber/v2"
-	"github.com/gofiber/fiber/v2/utils"
 	"github.com/newrelic/go-agent/v3/newrelic"
 )
 
@@ -66,33 +66,31 @@ func New(cfg Config) fiber.Handler {
 	}
 
 	return func(c *fiber.Ctx) error {
-		txn := app.StartTransaction("")
+		txn := app.StartTransaction(createTransactionName(c))
 		defer txn.End()
 
-		handlerErr := c.Next()
-
 		var (
-			method    = utils.CopyString(c.Method())
-			routePath = utils.CopyString(c.Route().Path)
-			host      = utils.CopyString(c.Hostname())
+			host   = utils.CopyString(c.Hostname())
+			method = utils.CopyString(c.Method())
 		)
 
-		u := url.URL{
-			Host:     host,
-			Scheme:   string(c.Request().URI().Scheme()),
-			Path:     string(c.Request().URI().Path()),
-			RawQuery: string(c.Request().URI().QueryString()),
-		}
-
-		txn.SetName(fmt.Sprintf("%s %s", method, routePath))
+		scheme := c.Request().URI().Scheme()
 
 		txn.SetWebRequest(newrelic.WebRequest{
-			URL:       &u,
-			Method:    method,
-			Transport: transport(u.Scheme),
 			Host:      host,
+			Method:    method,
+			Transport: transport(string(scheme)),
+			URL: &url.URL{
+				Host:     host,
+				Scheme:   string(c.Request().URI().Scheme()),
+				Path:     string(c.Request().URI().Path()),
+				RawQuery: string(c.Request().URI().QueryString()),
+			},
 		})
 
+		c.SetUserContext(newrelic.NewContext(c.UserContext(), txn))
+
+		handlerErr := c.Next()
 		statusCode := c.Context().Response.StatusCode()
 
 		if handlerErr != nil {
@@ -106,6 +104,16 @@ func New(cfg Config) fiber.Handler {
 	}
 }
 
+// FromContext returns the Transaction from the context if present, and nil
+// otherwise.
+func FromContext(c *fiber.Ctx) *newrelic.Transaction {
+	return newrelic.FromContext(c.UserContext())
+}
+
+func createTransactionName(c *fiber.Ctx) string {
+	return fmt.Sprintf("%s %s", c.Request().Header.Method(), c.Request().URI().Path())
+}
+
 func transport(schema string) newrelic.TransportType {
 	if strings.HasPrefix(schema, "https") {
 		return newrelic.TransportHTTPS

fibernewrelic/fiber_test.go

@@ -61,9 +61,9 @@ func TestNewrelicAppConfig(t *testing.T) {
 				return ctx.SendStatus(200)
 			})
 
-			r := httptest.NewRequest("GET", "/", nil)
+			r := httptest.NewRequest(http.MethodGet, "/", nil)
 			resp, _ := app.Test(r, -1)
-			assert.Equal(t, 200, resp.StatusCode)
+			assert.Equal(t, http.StatusOK, resp.StatusCode)
 		})
 
 	t.Run("Run successfully as middleware",
@@ -310,3 +310,35 @@ func TestDefaultErrorStatusCodeHandler(t *testing.T) {
 		assert.Equal(t, http.StatusNotFound, resp.StatusCode)
 	})
 }
+
+func TestFromContext(t *testing.T) {
+	// given
+	cfg := Config{
+		License: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
+		AppName: "",
+		Enabled: true,
+	}
+	app := fiber.New()
+	app.Use(New(cfg))
+	app.Get("/foo", func(ctx *fiber.Ctx) error {
+		tx := FromContext(ctx)
+
+		if tx.Name() != "GET /foo" {
+			return ctx.SendStatus(http.StatusInternalServerError)
+		}
+
+		segment := tx.StartSegment("foo")
+		defer segment.End()
+
+		return ctx.SendStatus(http.StatusOK)
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/foo", http.NoBody)
+
+	// when
+	res, err := app.Test(req, -1)
+
+	// then
+	assert.Nil(t, err)
+	assert.Equal(t, http.StatusOK, res.StatusCode)
+}