entrygraph 0.1.40__tar.gz → 0.1.41__tar.gz

{entrygraph-0.1.40 → entrygraph-0.1.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entrygraph
-Version: 0.1.40
+Version: 0.1.41
 Summary: Language-agnostic code graph: query symbols, entrypoints, and source-to-sink call paths from a SQLite index
 Project-URL: Repository, https://github.com/brettbergin/entrygraph
 Author-email: Brett Bergin <brettberginbc@yahoo.com>

{entrygraph-0.1.40 → entrygraph-0.1.41}/src/entrygraph/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.40'
-__version_tuple__ = version_tuple = (0, 1, 40)
+__version__ = version = '0.1.41'
+__version_tuple__ = version_tuple = (0, 1, 41)
 
 __commit_id__ = commit_id = None

{entrygraph-0.1.40 → entrygraph-0.1.41}/src/entrygraph/detect/entrypoints/golang.py

@@ -236,6 +236,51 @@ def _cobra_commands(x: FileExtraction) -> list[EntrypointHint]:
     return hints
 
 
+# gRPC service registration: `pb.RegisterFooServer(grpcServer, impl)`. The `Server`
+# suffix anchor keeps grpc-gateway's `RegisterFooHandler` / `...HandlerFromEndpoint`
+# out. Definitions (`func RegisterFooServer(...)`) are not call references, so only
+# real registration call sites match.
+_GRPC_REGISTER = re.compile(r"^Register(?P<service>[A-Za-z0-9]+)Server$")
+
+
+def _grpc_services(x: FileExtraction) -> list[EntrypointHint]:
+    """Mark each registered gRPC service as an RPC entrypoint (one per service).
+
+    This is a service-level marker: the implementation (arg 2) is almost always a
+    field/local var (`t.Ingester`, `frontendV1`) whose concrete type the IR can't
+    infer, so the entrypoint anchors on the registration file's module rather than
+    expanding to the impl's individual RPC methods. The service name rides in
+    `route` — the Entrypoint row has no name column, and it keeps distinct services
+    from collapsing in dedup (they all share `handler_qualified_name=None`).
+    """
+    if x.path.endswith("_test.go"):
+        return []  # test harnesses spin up real services; not production surface (#33)
+    hints = []
+    seen: set[str] = set()
+    for ref in x.references:
+        if ref.kind != "call":
+            continue
+        m = _GRPC_REGISTER.match(ref.callee_name)
+        if m is None:
+            continue
+        service = m.group("service")
+        if service in seen:
+            continue
+        seen.add(service)
+        hints.append(
+            EntrypointHint(
+                rule_id="go.grpc.service",
+                kind=EntrypointKind.RPC_HANDLER,
+                handler_qualified_name=None,
+                route=f"/{service}",
+                name=service,
+                framework="grpc-go",
+                span=ref.span,
+            )
+        )
+    return hints
+
+
 register(EntrypointRule("go.core.main", "go", None, EntrypointKind.MAIN, _go_main))
 register(
     EntrypointRule("go.nethttp.route", "go", "net/http", EntrypointKind.HTTP_ROUTE, _nethttp_routes)
@@ -253,3 +298,6 @@ register(
 register(
     EntrypointRule("go.cobra.command", "go", "cobra", EntrypointKind.CLI_COMMAND, _cobra_commands)
 )
+register(
+    EntrypointRule("go.grpc.service", "go", "grpc-go", EntrypointKind.RPC_HANDLER, _grpc_services)
+)

{entrygraph-0.1.40 → entrygraph-0.1.41}/src/entrygraph/kinds.py

@@ -40,6 +40,7 @@ class EntrypointKind(enum.Enum):
     LAMBDA_HANDLER = "lambda_handler"
     EVENT_HANDLER = "event_handler"
     MIDDLEWARE = "middleware"  # request/response interceptor (before_request, app.use, ...)
+    RPC_HANDLER = "rpc_handler"  # gRPC / RPC service registration (RegisterXxxServer)
 
 
 class Confidence(enum.IntEnum):

{entrygraph-0.1.40 → entrygraph-0.1.41}/tests/test_entrypoints_go.py

@@ -71,3 +71,50 @@ def test_chi_mount_prefix_not_composed_across_functions():
     ]
     got = {(h.http_methods[0], h.route) for h in _chi_rule().match(_go_ext(refs))}
     assert got == {("GET", "/health")}  # no phantom /api prefix
+
+
+def _grpc_rule():
+    return {r.id: r for r in rules_for("go", {"grpc-go"})}["go.grpc.service"]
+
+
+def test_grpc_service_registration_detected():
+    # pb.RegisterPusherServer(grpcServer, t.Ingester) -> one RPC entrypoint whose
+    # service name rides in `route` (no name column; keeps services distinct in
+    # dedup since they all share handler=None). Impl type is unresolvable, so the
+    # handler is left unbound (scanner anchors it on the module) (#37).
+    refs = [
+        _call("RegisterPusherServer", "logproto", "(t.Server.GRPC, t.Ingester)"),
+        _call("RegisterQuerierServer", "logproto", "(t.Server.GRPC, t.Ingester)", start=2),
+    ]
+    hints = _grpc_rule().match(_go_ext(refs, path="pkg/loki/modules.go"))
+    got = {(h.route, h.name, h.framework, h.handler_qualified_name) for h in hints}
+    assert got == {
+        ("/Pusher", "Pusher", "grpc-go", None),
+        ("/Querier", "Querier", "grpc-go", None),
+    }
+
+
+def test_grpc_same_service_deduped_within_file():
+    refs = [
+        _call("RegisterPusherServer", "logproto", "(s, t.distributor)"),
+        _call("RegisterPusherServer", "logproto", "(s, t.Ingester)", start=2),
+    ]
+    hints = _grpc_rule().match(_go_ext(refs, path="pkg/loki/modules.go"))
+    assert [h.route for h in hints] == ["/Pusher"]
+
+
+def test_grpc_gateway_and_non_server_calls_ignored():
+    # grpc-gateway registrars end in `Handler`/`HandlerFromEndpoint`, not `Server`,
+    # and must not be treated as service registrations.
+    refs = [
+        _call("RegisterPusherHandler", "gw", "(ctx, mux, conn)"),
+        _call("RegisterPusherHandlerFromEndpoint", "gw", "(ctx, mux, addr, opts)", start=2),
+        _call("Serve", "grpcServer", "(lis)", start=3),
+    ]
+    assert _grpc_rule().match(_go_ext(refs, path="pkg/loki/modules.go")) == []
+
+
+def test_grpc_test_harness_registrations_excluded():
+    # A real service registered inside a *_test.go harness is not production surface.
+    refs = [_call("RegisterFrontendServer", "frontendv1pb", "(grpcServer, v1)")]
+    assert _grpc_rule().match(_go_ext(refs, path="pkg/frontend/frontend_test.go")) == []