chore: post-PR-triad fixes (review + simplify)

Code review (pr-review-toolkit):
- rpc.go: drop dead `resp.Message = err.Error()` writes — Connect
  discards the response on any non-nil error, so the assignments were
  never observed by callers. Hoist resp allocation past the err guard
  so the success path is the only allocator.
- plugin.go: introduce errPluginNotFound sentinel and an
  errors.Is-based mapping helper (connectCodeFor) so the rpc handler
  returns connect.CodeNotFound for missing plugins instead of
  CodeInternal. CodeInternal is still the default for any other error.
- plugin.go: rewrite stale doc on the private status()/ready() helpers
  (the prior wording was a copy-paste leftover from the goridge era
  describing a public method that no longer exists).
- tests/plugin_test.go: drive-by lint cleanups — 3 more
  http.NewRequest -> NewRequestWithContext(t.Context(), ...) sites
  surfaced after fixing the first batch.
- tests/plugin_test.go: assert connect.CodeNotFound on the
  StatusNonExistent / ReadyNonExistent subtests instead of string-
  matching err.Error() — the typed sentinel makes the wire-code check
  more robust.
- tests/plugin_test.go: TestRPCNonExistentPlugin no longer registers
  http+server plugins. The test only exercises the "no such plugin"
  path of the status RPC handler, doesn't need any Checker/Readiness
  providers, and the previous setup pulled in a PHP worker dependency
  that broke the test in PHP-less environments.

Simplify:
- Tighten doc comments on errPluginNotFound and connectCodeFor (cut
  WHAT, keep WHY).
- Drop the now-unused errors.Op constants in status() and ready()
  after dropping the errors.E wrap on the not-found path
  (the wrap was hiding the sentinel from errors.Is — *errors.Error
  has no Unwrap method).

Author: rustatian

plugin.go

@@ -3,6 +3,7 @@ package status
 import (
 	"context"
 	stderr "errors"
+	"fmt"
 	"log/slog"
 	"net/http"
 	"sync"
@@ -16,6 +17,9 @@ import (
 	"github.com/roadrunner-server/errors"
 )
 
+// Mapped to connect.CodeNotFound by the rpc handler; other failures surface as CodeInternal.
+var errPluginNotFound = stderr.New("no such plugin")
+
 const (
 	// PluginName declares public plugin name.
 	PluginName          = "status"
@@ -133,25 +137,25 @@ func (c *Plugin) Stop(_ context.Context) error {
 	return nil
 }
 
-// Status returns a Checker interface implementation
-// Reset named service.
-// This is not a Status interface implementation
+// status looks up the named plugin in the status registry and delegates to its
+// Checker.Status. Returns errPluginNotFound (wrapped) if the name is not
+// registered.
 func (c *Plugin) status(name string) (*status.Status, error) {
-	const op = errors.Op("checker_plugin_status")
 	svc, ok := c.statusRegistry[name]
 	if !ok {
-		return nil, errors.E(op, errors.Errorf("no such plugin: %s", name))
+		return nil, fmt.Errorf("%w: %s", errPluginNotFound, name)
 	}
 
 	return svc.Status()
 }
 
-// ready is used to provide a readiness check for the plugin
+// ready looks up the named plugin in the readiness registry and delegates to
+// its Readiness.Ready. Returns errPluginNotFound (wrapped) if the name is not
+// registered.
 func (c *Plugin) ready(name string) (*status.Status, error) {
-	const op = errors.Op("checker_plugin_ready")
 	svc, ok := c.readyRegistry[name]
 	if !ok {
-		return nil, errors.E(op, errors.Errorf("no such plugin: %s", name))
+		return nil, fmt.Errorf("%w: %s", errPluginNotFound, name)
 	}
 
 	return svc.Ready()

rpc.go

@@ -2,6 +2,7 @@ package status
 
 import (
 	"context"
+	stderr "errors"
 	"log/slog"
 
 	"connectrpc.com/connect"
@@ -14,19 +15,26 @@ type rpc struct {
 	log *slog.Logger
 }
 
+// connectCodeFor returns CodeNotFound for a missing plugin, CodeInternal otherwise.
+func connectCodeFor(err error) connect.Code {
+	if stderr.Is(err, errPluginNotFound) {
+		return connect.CodeNotFound
+	}
+	return connect.CodeInternal
+}
+
 // Status returns the current status of the provided plugin.
 func (r *rpc) Status(_ context.Context, req *connect.Request[statusV2.StatusRequest]) (*connect.Response[statusV2.StatusResponse], error) {
 	const op = errors.Op("checker_rpc_status")
 	plugin := req.Msg.GetPlugin()
 	r.log.Debug("Status method was invoked", "plugin", plugin)
 
-	resp := &statusV2.StatusResponse{}
 	st, err := r.srv.status(plugin)
 	if err != nil {
-		resp.Message = err.Error()
-		return nil, connect.NewError(connect.CodeInternal, errors.E(op, err))
+		return nil, connect.NewError(connectCodeFor(err), errors.E(op, err))
 	}
 
+	resp := &statusV2.StatusResponse{}
 	if st != nil {
 		resp.Code = int64(st.Code)
 		r.log.Debug("status code", "code", st.Code)
@@ -42,13 +50,12 @@ func (r *rpc) Ready(_ context.Context, req *connect.Request[statusV2.StatusReque
 	plugin := req.Msg.GetPlugin()
 	r.log.Debug("Ready method was invoked", "plugin", plugin)
 
-	resp := &statusV2.StatusResponse{}
 	st, err := r.srv.ready(plugin)
 	if err != nil {
-		resp.Message = err.Error()
-		return nil, connect.NewError(connect.CodeInternal, errors.E(op, err))
+		return nil, connect.NewError(connectCodeFor(err), errors.E(op, err))
 	}
 
+	resp := &statusV2.StatusResponse{}
 	if st != nil {
 		resp.Code = int64(st.Code)
 		r.log.Debug("status code", "code", st.Code)

tests/plugin_test.go

@@ -669,13 +669,14 @@ func TestRPCNonExistentPlugin(t *testing.T) {
 		Path:    "configs/.rr-status-init.yaml",
 	}
 
+	// Minimal stack: this test only verifies the "no such plugin" path of the
+	// status RPC handler, so no Checker/Readiness providers are needed and
+	// http/server are dropped to keep the test PHP-independent.
 	sp := &status.Plugin{}
 	err := cont.RegisterAll(
 		cfg,
 		&rpcPlugin.Plugin{},
 		&logger.Plugin{},
-		&server.Plugin{},
-		&httpPlugin.Plugin{},
 		sp,
 	)
 	assert.NoError(t, err)
@@ -728,14 +729,14 @@ func TestRPCNonExistentPlugin(t *testing.T) {
 		client := newStatusClient(t, "127.0.0.1:6005")
 		_, err := client.Status(t.Context(), connect.NewRequest(&statusV2.StatusRequest{Plugin: "nonexistent"}))
 		require.Error(t, err)
-		assert.Contains(t, err.Error(), "no such plugin")
+		assert.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 	})
 
 	t.Run("ReadyNonExistent", func(t *testing.T) {
 		client := newStatusClient(t, "127.0.0.1:6005")
 		_, err := client.Ready(t.Context(), connect.NewRequest(&statusV2.StatusRequest{Plugin: "nonexistent"}))
 		require.Error(t, err)
-		assert.Contains(t, err.Error(), "no such plugin")
+		assert.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 	})
 
 	stopCh <- struct{}{}
@@ -830,7 +831,7 @@ func doHTTPReq(t *testing.T) {
 }
 
 func checkHTTPReadiness2(t *testing.T) {
-	req, err := http.NewRequest("GET", "http://127.0.0.1:34334/ready?plugin=http&plugin=rpc", nil)
+	req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://127.0.0.1:34334/ready?plugin=http&plugin=rpc", nil)
 	assert.NoError(t, err)
 
 	r, err := http.DefaultClient.Do(req)
@@ -852,7 +853,7 @@ func checkHTTPReadiness2(t *testing.T) {
 }
 
 func checkHTTPReadinessAll(t *testing.T) {
-	req, err := http.NewRequest("GET", "http://127.0.0.1:34333/ready", nil)
+	req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://127.0.0.1:34333/ready", nil)
 	assert.NoError(t, err)
 
 	r, err := http.DefaultClient.Do(req)
@@ -869,7 +870,7 @@ func checkHTTPReadinessAll(t *testing.T) {
 }
 
 func checkHTTPReadiness(t *testing.T) {
-	req, err := http.NewRequest("GET", "http://127.0.0.1:34333/ready?plugin=http&plugin=rpc", nil)
+	req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://127.0.0.1:34333/ready?plugin=http&plugin=rpc", nil)
 	assert.NoError(t, err)
 
 	r, err := http.DefaultClient.Do(req)