repo-sync-2024-05-13T14:58:14+0800 (#61)

Author: oeqqwq

examples/BUILD.bazel

@@ -20,8 +20,10 @@ filegroup(
         "alice/glm-test.tar.gz",
         "alice/logging.config",
         "alice/serving.config",
+        "alice/trace.config",
         "bob/glm-test.tar.gz",
         "bob/logging.config",
         "bob/serving.config",
+        "bob/trace.config",
     ],
 )

secretflow_serving/feature_adapter/http_adapter.cc

@@ -118,24 +118,29 @@ void HttpFeatureAdapter::OnFetchFeature(const Request& request,
   channel_->CallMethod(NULL, &cntl, NULL, NULL, NULL);
   if (cntl.Failed()) {
     span_option.code = errors::ErrorCode::NETWORK_ERROR;
-    span_option.msg =
-        fmt::format("http request failed, endpoint:{}, detail:{}",
-                    spec_.http_opts().endpoint(), cntl.ErrorText());
+    span_option.msg = fmt::format(
+        "http request failed, endpoint:{}, request: {}, error info detail:{}",
+        spec_.http_opts().endpoint(), spi_request, cntl.ErrorText());
   } else {
     auto status = ::google::protobuf::util::JsonStringToMessage(
         cntl.response_attachment().to_string(), &spi_response);
     if (!status.ok()) {
       span_option.code = errors::ErrorCode::DESERIALIZE_FAILED;
-      span_option.msg = fmt::format("deserialize response context failed: {}",
-                                    status.ToString());
+      span_option.msg = fmt::format(
+          "deserialize response context failed: request: {}, error: {}",
+          spi_request, status.ToString());
+
     } else if (spi_response.status().code() != spis::ErrorCode::OK) {
       span_option.code = MappingErrorCode(spi_response.status().code());
       span_option.msg = fmt::format(
-          "fetch features response error, msg: {}, code: {}",
-          spi_response.status().msg(), spi_response.status().code());
+          "fetch features response error, request: {}, msg: {}, code: {}",
+          spi_request, spi_response.status().msg(),
+          spi_response.status().code());
+
     } else if (spi_response.features().empty()) {
       span_option.code = errors::ErrorCode::IO_ERROR;
-      span_option.msg = "get empty features.";
+      span_option.msg =
+          fmt::format("get empty features, request: {}", spi_request);
     }
   }
 

secretflow_serving/framework/model_info_collector.cc

@@ -96,6 +96,9 @@ ModelInfoCollector::ModelInfoCollector(Options opts) : opts_(std::move(opts)) {
         node_view, std::set<std::string>(node_view.parents().begin(),
                                          node_view.parents().end()));
   }
+
+  SPDLOG_INFO("local model info: party: {} : {}", opts_.self_party_id,
+              PbToJson(&model_info_));
 }
 
 void ModelInfoCollector::DoCollect() {
@@ -107,6 +110,10 @@ void ModelInfoCollector::DoCollect() {
                     "GetModelInfo from {} failed.", remote_party_id);
   }
 
+  for (const auto& [remote_party_id, model_info] : model_info_map_) {
+    SPDLOG_INFO("model info: party: {} : {}", remote_party_id,
+                PbToJson(&model_info));
+  }
   CheckAndSetSpecificMap();
 }
 

secretflow_serving/server/execution_core.cc

@@ -20,6 +20,7 @@
 #include "secretflow_serving/feature_adapter/feature_adapter_factory.h"
 #include "secretflow_serving/util/arrow_helper.h"
 #include "secretflow_serving/util/thread_pool.h"
+#include "secretflow_serving/util/utils.h"
 
 namespace secretflow::serving {
 
@@ -134,12 +135,14 @@ void ExecutionCore::Execute(const apis::ExecuteRequest* request,
     }
     response->mutable_status()->set_code(errors::ErrorCode::OK);
   } catch (const Exception& e) {
-    SPDLOG_ERROR("execute failed, code:{}, msg:{}, stack:{}", e.code(),
-                 e.what(), e.stack_trace());
+    SPDLOG_ERROR("execute failed, request: {}, code:{}, msg:{}, stack:{}",
+                 PbToJsonNoExcept(request), e.code(), e.what(),
+                 e.stack_trace());
     response->mutable_status()->set_code(e.code());
     response->mutable_status()->set_msg(e.what());
   } catch (const std::exception& e) {
-    SPDLOG_ERROR("execute failed, msg:{}", e.what());
+    SPDLOG_ERROR("execute failed, request: {}, msg:{}",
+                 PbToJsonNoExcept(request), e.what());
     response->mutable_status()->set_code(errors::ErrorCode::UNEXPECTED_ERROR);
     response->mutable_status()->set_msg(e.what());
   }

secretflow_serving/server/prediction_core.cc

@@ -52,12 +52,14 @@ void PredictionCore::Predict(const apis::PredictRequest* request,
     opts_.predictor->Predict(request, response);
     status->set_code(errors::ErrorCode::OK);
   } catch (const Exception& e) {
-    SPDLOG_ERROR("Predict failed, code:{}, msg:{}, stack:{}", e.code(),
-                 e.what(), e.stack_trace());
+    SPDLOG_ERROR("Predict failed, request: {}, code:{}, msg:{}, stack:{}",
+                 PbToJsonNoExcept(request), e.code(), e.what(),
+                 e.stack_trace());
     response->mutable_status()->set_code(e.code());
     response->mutable_status()->set_msg(e.what());
   } catch (const std::exception& e) {
-    SPDLOG_ERROR("Predict failed, msg:{}", e.what());
+    SPDLOG_ERROR("Predict failed, request: {}, msg:{}",
+                 PbToJsonNoExcept(request), e.what());
     response->mutable_status()->set_code(errors::ErrorCode::UNEXPECTED_ERROR);
     response->mutable_status()->set_msg(e.what());
   }

secretflow_serving/util/thread_safe_queue.h

@@ -42,7 +42,7 @@ class ThreadSafeQueue {
       buffer_[i] = std::move(buffer[i]);
     }
     SERVING_ENFORCE(wait_ms_ > 0, errors::ErrorCode::INVALID_ARGUMENT,
-                    "wait_ms should not be zero", wait_ms_);
+                    "wait_ms({}) should not be zero", wait_ms_);
   }
 
   ThreadSafeQueue(const ThreadSafeQueue&) = delete;

secretflow_serving/util/utils.cc

@@ -67,4 +67,13 @@ std::string PbToJson(const ::google::protobuf::Message* message) {
   return json;
 }
 
+std::string PbToJsonNoExcept(
+    const ::google::protobuf::Message* message) noexcept {
+  try {
+    return PbToJson(message);
+  } catch (...) {
+    return "ill_format_message";
+  }
+}
+
 }  // namespace secretflow::serving

secretflow_serving/util/utils.h

@@ -42,6 +42,9 @@ void JsonToPb(const std::string& json, ::google::protobuf::Message* message);
 
 std::string PbToJson(const ::google::protobuf::Message* message);
 
+std::string PbToJsonNoExcept(
+    const ::google::protobuf::Message* message) noexcept;
+
 template <typename Func>
 void FeatureVisit(Func&& visitor, const Feature& f) {
   switch (f.field().type()) {
@@ -70,7 +73,7 @@ void FeatureVisit(Func&& visitor, const Feature& f) {
       break;
     }
     default:
-      SERVING_THROW(errors::ErrorCode::UNEXPECTED_ERROR, "unkown field type",
+      SERVING_THROW(errors::ErrorCode::UNEXPECTED_ERROR, "unkown field type {}",
                     FieldType_Name(f.field().type()));
   }
 }