Improvement suggestion for error handling

[yeldiRium]

Hi there,

thanks for making this great package. It aids me a lot in building my own
language server and I like it quite a bit.

However I have an improvement suggestion. I am currently trying to wrap the lps
server handler to add telemetry. With web servers and other kinds of servers you
would usually do this by wrapping the handler and recording some information
about its execution. This currently looks like this, where innerHandler is a
jsonrpc2.Handler as returned by protocol.ServerHandler(...).

func WrapInTelemetry(telemetry *Telemetry, innerHandler jsonrpc2.Handler) jsonrpc2.Handler {
	wrappedHandler := func(ctx context.Context, reply jsonrpc2.Replier, req jsonrpc2.Request) error {
		ctx, span := telemetry.Tracer.Start(ctx, req.Method())
		defer span.End()

		SetGlobalAttributes(span)

		err := innerHandler(ctx, reply, req)
		if err != nil {
			telemetry.logger.Sugar().Errorf("error occured and is being sent to telemetry!")
			span.SetStatus(codes.Error, "handler failed")
			span.RecordError(err)
			return err
		}

		span.SetStatus(codes.Ok, "handler succeeded")
		return nil
	}

	return wrappedHandler
}

Now I'm running into a problem: The inner handler does not propagate errors.

This is due the behavior in serverDispatch,
where all of the handlers handle errors by sending them to the client - which
makes sense - but then not propagating the error, but only returning an error
to the server, if sending the reply to the client failed.

This is probably done to keep the error handling localized and not expose
errors to the server that can be dealt with by informing the client about them.
However, if the error can't be handled by telling the client about it - and I
have some of these kinds of errors - then the server needs to be able to at
least know about them and log them.

Do you think there is a way to change this behavior without breaking everything?
Or is there an alternative way for my wrapper to know that an error occured?