logging: Add better logging on IPC server-side failures

Motivation: when trying to add a new unit test ran into a confusing error
"(remote):0: failed: remote exception: Called null capability" caused by
forgetting to make a FooInterface.initThreadMap call during initialization and
these logging prints would have made it easier to see where the error was
coming from and debug.

Author: ryanofsky

include/mp/proxy-types.h

@@ -719,6 +719,13 @@ kj::Promise<void> serverInvoke(Server& server, CallContext& call_context, Fn fn)
             .then([&server, req](CallContext call_context) {
                 server.m_context.loop->log() << "IPC server send response #" << req << " " << TypeName<Results>()
                                                  << " " << LogEscape(call_context.getResults().toString(), server.m_context.loop->m_log_opts.max_chars);
+            }, [&server, req](::kj::Exception&& e) {
+                // Call failed for some reason. Cap'n Proto will try to send
+                // this error to the client as well, but it is good to log the
+                // failure early here and include the request number.
+                server.m_context.loop->log() << "IPC server error request #" << req << " " << TypeName<Results>()
+                                                 << " " << kj::str("kj::Exception: ", e).cStr();
+                return kj::mv(e);
             });
     } catch (const std::exception& e) {
         server.m_context.loop->log() << "IPC server unhandled exception: " << e.what();

include/mp/type-context.h

@@ -158,6 +158,40 @@ auto PassField(Priority<1>, TypeList<>, ServerContext& server_context, const Fn&
                     << "IPC server error request #" << req << ", missing thread to execute request";
                 throw std::runtime_error("invalid thread handle");
             }
+        }, [&server, req](::kj::Exception&& e) {
+            // If you see the error "(remote):0: failed: remote exception:
+            // Called null capability" here, it probably means your Init class
+            // is missing a declaration like:
+            //
+            //   construct @0 (threadMap: Proxy.ThreadMap) -> (threadMap :Proxy.ThreadMap);
+            //
+            // which passes a ThreadMap reference from the client to the server,
+            // allowing the server to create threads to run IPC calls on the
+            // client, and also returns a ThreadMap reference from the server to
+            // the client, allowing the client to create threads on the server.
+            // (Typically the latter ThreadMap is used more often because there
+            // are more client-to-server calls.)
+            //
+            // If the other side of the connection did not previously get a
+            // ThreadMap reference from this side of the connection, when the
+            // other side calls `m_thread_map.makeThreadRequest()` in
+            // `BuildField` above, `m_thread_map` will be null, but that call
+            // will not fail immediately due to Cap'n Proto's request pipelining
+            // and delayed execution. Instead that call will return an invalid
+            // Thread reference, and when that reference is passed to this side
+            // of the connection as `thread_client` above, the
+            // `getLocalServer(thread_client)` call there will be the first
+            // thing to overtly fail, leading to an error here.
+            //
+            // Potentially there are also other things that could cause errors
+            // here, but this is the mostly likely cause.
+            //
+            // The log statement here is not strictly necessary since the same
+            // exception will also be logged in serverInvoke, but this logging
+            // may provide extra context that could be helpful for debugging.
+            server.m_context.loop->log()
+                << "IPC server error request #" << req << " CapabilityServerSet<Thread>::getLocalServer call failed, did you forget to provide a ThreadMap to the client prior to this IPC call?";
+            return kj::mv(e);
         })
         // Wait for the invocation to finish before returning to the caller.
         .then([invoke_wait = kj::mv(future.promise)]() mutable { return kj::mv(invoke_wait); });