Normalized route names when using Lumen (#535)

Co-authored-by: Alex Bouma <[email protected]>

Author: migralito

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Add support for normalized route names when using Lumen (#449)
+
 ## 2.11.1
 
 - Fix deprecation notice in route name extraction (#543)

src/Sentry/Laravel/Integration.php

@@ -145,28 +145,82 @@ public static function extractNameForRoute(Route $route): string
         return $routeName;
     }
 
-    private static function extractNameForNamedRoute(string $routeName): ?string
+    /**
+     * Extract the readable name for a Lumen route.
+     *
+     * @param array  $routeData The array of route data
+     * @param string $path      The path of the request
+     *
+     * @return string
+     */
+    public static function extractNameForLumenRoute(array $routeData, string $path): string
+    {
+        $routeName = null;
+
+        $route = $routeData[1] ?? [];
+
+        // someaction (route name/alias)
+        if (!empty($route['as'])) {
+            $routeName = self::extractNameForNamedRoute($route['as']);
+        }
+
+        // Some\Controller@someAction (controller action)
+        if (empty($routeName) && !empty($route['uses'])) {
+            $routeName = self::extractNameForActionRoute($route['uses']);
+        }
+
+        // /someaction // Fallback to the url
+        if (empty($routeName) || $routeName === 'Closure') {
+            $routeUri = array_reduce(
+                array_keys($routeData[2]),
+                static function ($carry, $key) use ($routeData) {
+                    return str_replace($routeData[2][$key], "{{$key}}", $carry);
+                },
+                $path
+            );
+
+            $routeName = '/' . ltrim($routeUri, '/');
+        }
+
+        return $routeName;
+    }
+
+    /**
+     * Take a route name and return it only if it's a usable route name.
+     *
+     * @param string $name
+     *
+     * @return string|null
+     */
+    private static function extractNameForNamedRoute(string $name): ?string
     {
         // Laravel 7 route caching generates a route names if the user didn't specify one
         // theirselfs to optimize route matching. These route names are useless to the
         // developer so if we encounter a generated route name we discard the value
-        if (Str::contains($routeName, 'generated::')) {
+        if (Str::contains($name, 'generated::')) {
             return null;
         }
 
         // If the route name ends with a `.` we assume an incomplete group name prefix
         // we discard this value since it will most likely not mean anything to the
         // developer and will be duplicated by other unnamed routes in the group
-        if (Str::endsWith($routeName, '.')) {
+        if (Str::endsWith($name, '.')) {
             return null;
         }
 
-        return $routeName;
+        return $name;
     }
 
-    private static function extractNameForActionRoute(string $actionName): string
+    /**
+     * Take a controller action and strip away the base namespace if needed.
+     *
+     * @param string $action
+     *
+     * @return string
+     */
+    private static function extractNameForActionRoute(string $action): string
     {
-        $routeName = ltrim($actionName, '\\');
+        $routeName = ltrim($action, '\\');
 
         $baseNamespace = self::$baseControllerNamespace ?? '';
 

src/Sentry/Laravel/Tracing/Middleware.php

@@ -180,13 +180,27 @@ private function hydrateRequestData(Request $request): void
         $route = $request->route();
 
         if ($route instanceof Route) {
-            $this->updateTransactionNameIfDefault(Integration::extractNameForRoute($route));
+            $this->updateTransactionNameIfDefault(
+                Integration::extractNameForRoute($route)
+            );
 
             $this->transaction->setData([
                 'name' => $route->getName(),
                 'action' => $route->getActionName(),
                 'method' => $request->getMethod(),
             ]);
+        } elseif (is_array($route) && count($route) === 3) {
+            $this->updateTransactionNameIfDefault(
+                Integration::extractNameForLumenRoute($route, $request->path())
+            );
+
+            $action = $route[1] ?? [];
+
+            $this->transaction->setData([
+                'name' => $action['as'] ?? null,
+                'action' => $action['uses'] ?? 'Closure',
+                'method' => $request->getMethod(),
+            ]);
         }
 
         $this->updateTransactionNameIfDefault('/' . ltrim($request->path(), '/'));

test/Sentry/IntegrationTest.php

@@ -162,4 +162,83 @@ public function testExtractingNameForRouteWithStrippedBaseNamespaceFromAction():
 
         Integration::setControllersBaseNamespace(null);
     }
+
+    public function testExtractingNameForLumenRouteWithName(): void
+    {
+        $route = [0, ['as' => $routeName = 'foo-bar'], []];
+
+        $this->assertSame($routeName, Integration::extractNameForLumenRoute($route, '/some-route'));
+    }
+
+    public function testExtractingNameForLumenRouteWithAction(): void
+    {
+        $route = [0, ['uses' => $controller = 'SomeController@someAction'], []];
+
+        $this->assertSame($controller, Integration::extractNameForLumenRoute($route, '/some-route'));
+    }
+
+    public function testExtractingNameForLumenRouteWithoutName(): void
+    {
+        $url = '/some-route';
+
+        $this->assertSame($url, Integration::extractNameForLumenRoute([0, [], []], $url));
+    }
+
+    public function testExtractingNameForLumenRouteWithParamInUrl(): void
+    {
+        $route = [1, [], ['param1' => 'foo']];
+
+        $url = '/foo/bar/baz';
+
+        $this->assertSame('/{param1}/bar/baz', Integration::extractNameForLumenRoute($route, $url));
+    }
+
+    public function testExtractingNameForLumenRouteWithParamsInUrl(): void
+    {
+        $route = [1, [], ['param1' => 'foo', 'param2' => 'bar']];
+
+        $url = '/foo/bar/baz';
+
+        $this->assertSame('/{param1}/{param2}/baz', Integration::extractNameForLumenRoute($route, $url));
+    }
+
+    public function testExtractingNameForLumenRouteWithActionAndName(): void
+    {
+        $route = [0, [
+            'as' => $routeName = 'foo-bar',
+            'uses' => 'SomeController@someAction',
+        ], []];
+
+        $this->assertSame($routeName, Integration::extractNameForLumenRoute($route, '/some-route'));
+    }
+
+    public function testExtractingNameForLumenRouteWithAutoGeneratedName(): void
+    {
+        // We fake a generated name here, Laravel generates them each starting with `generated::`
+        $route = [0, ['as' => 'generated::KoAePbpBofo01ey4'], []];
+
+        $url = '/some-route';
+
+        $this->assertSame($url, Integration::extractNameForLumenRoute($route, $url));
+    }
+
+    public function testExtractingNameForLumenRouteWithIncompleteGroupName(): void
+    {
+        $route = [0, ['as' => 'group-name.'], []];
+
+        $url = '/some-route';
+
+        $this->assertSame($url, Integration::extractNameForLumenRoute($route, $url));
+    }
+
+    public function testExtractingNameForLumenRouteWithStrippedBaseNamespaceFromAction(): void
+    {
+        Integration::setControllersBaseNamespace('BaseNamespace');
+
+        $route = [0, ['uses' => 'BaseNamespace\\SomeController@someAction'], []];
+
+        $this->assertSame('SomeController@someAction', Integration::extractNameForLumenRoute($route, '/some-route'));
+
+        Integration::setControllersBaseNamespace(null);
+    }
 }