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

@@ -776,14 +776,16 @@ extern std::atomic<int> server_reqs;
 template <typename Server, typename CallContext, typename Fn>
 kj::Promise<void> serverInvoke(Server& server, CallContext& call_context, Fn fn)
 {
+    auto server_cap = server.thisCap();
     auto params = call_context.getParams();
     using Params = decltype(params);
     using Results = typename decltype(call_context.getResults())::Builds;
 
+    EventLoop& loop = *server.m_context.loop;
     int req = ++server_reqs;
-    MP_LOG(*server.m_context.loop, Log::Debug) << "IPC server recv request  #" << req << " "
-                                     << TypeName<typename Params::Reads>();
-    MP_LOG(*server.m_context.loop, Log::Trace) << "request data: "
+    MP_LOG(loop, Log::Debug) << "IPC server recv request  #" << req << " "
+        << TypeName<typename Params::Reads>();
+    MP_LOG(loop, Log::Trace) << "request data: "
         << LogEscape(params.toString(), server.m_context.loop->m_log_opts.max_chars);
 
     try {
@@ -799,16 +801,23 @@ kj::Promise<void> serverInvoke(Server& server, CallContext& call_context, Fn fn)
         // and waiting for it to complete.
         return ReplaceVoid([&]() { return fn.invoke(server_context, ArgList()); },
             [&]() { return kj::Promise<CallContext>(kj::mv(call_context)); })
-            .then([&server, req](CallContext call_context) {
-                MP_LOG(*server.m_context.loop, Log::Debug) << "IPC server send response #" << req << " " << TypeName<Results>();
-                MP_LOG(*server.m_context.loop, Log::Trace) << "response data: "
+            .then([&server, &loop, server_cap, req](CallContext call_context) {
+                MP_LOG(loop, Log::Debug) << "IPC server send response #" << req << " " << TypeName<Results>();
+                MP_LOG(loop, Log::Trace) << "response data: "
                     << LogEscape(call_context.getResults().toString(), server.m_context.loop->m_log_opts.max_chars);
+            }).catch_([&loop, server_cap, req](::kj::Exception&& e) -> kj::Promise<void> {
+                // 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.
+                MP_LOG(loop, Log::Error) << "IPC server error request #" << req << " " << TypeName<Results>()
+                    << " " << kj::str("kj::Exception: ", e.getDescription()).cStr();
+                return kj::mv(e);
             });
     } catch (const std::exception& e) {
-        MP_LOG(*server.m_context.loop, Log::Error) << "IPC server unhandled exception: " << e.what();
+        MP_LOG(loop, Log::Error) << "IPC server unhandled exception: " << e.what();
         throw;
     } catch (...) {
-        MP_LOG(*server.m_context.loop, Log::Error) << "IPC server unhandled exception";
+        MP_LOG(loop, Log::Error) << "IPC server unhandled exception";
         throw;
     }
 }

include/mp/type-context.h

@@ -216,6 +216,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");
             }
+        }, [&loop, req](::kj::Exception&& e) -> kj::Promise<typename ServerContext::CallContext> {
+            // 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 most 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.
+            MP_LOG(loop, Log::Info)
+                << "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);
         });
     // Use connection m_canceler object to cancel the result promise if the
     // connection is destroyed. (By default Cap'n Proto does not cancel requests