Scuba Logger for Swift Glass Client

Summary:
This diff implements a Scuba logger for the Swift Glass client. The logger is designed to capture request information and log it to Scuba for future analysis.

The [swift_glass_client](https://fburl.com/scuba/swift_glass_client/90h9dkm1) scuba table has been created

### Purpose

The Scuba logger is designed to provide insights into the performance and usage of the Swift Glass client. By capturing request information and logging it to Scuba, developers can analyze trends, identify issues, and optimize the client for better performance.

Reviewed By: Wilfred

Differential Revision: D78991582

fbshipit-source-id: 5b56f7f7103f5776e5d8a770a0a31c6a38a795ab

Author: ivanmurashko

glean/client/swift/GlassAccess.cpp

@@ -26,7 +26,6 @@ GlassAccess::GlassAccess() : client(nullptr), hgRoot_(getHgRoot()) {}
 
 std::optional<protocol::LocationList> GlassAccess::usrToDefinition(
     const std::string& usr) {
-  facebook::glean::swift::Clock clock;
   std::string msg;
 
   // Check if this is a Swift USR (starts with "s:")
@@ -37,9 +36,6 @@ std::optional<protocol::LocationList> GlassAccess::usrToDefinition(
     // Handle non-Swift USR using clangUSRToDefinition with hash
     return handleUSRHash(usr, msg);
   }
-
-  auto duration = clock.duration();
-  LOG(INFO) << "usrToDefinition request took " << duration << " milliseconds";
 }
 
 std::optional<protocol::LocationList> GlassAccess::handleUSR(

glean/client/swift/JsonServer.cpp

@@ -8,8 +8,13 @@
 
 #include "glean/client/swift/JsonServer.h"
 #include <folly/json.h>
+#include "glean/client/swift/Clock.h"
 
-JsonServer::JsonServer() : running_(false), glassAccess_(nullptr) {}
+JsonServer::JsonServer() : running_(false), glassAccess_(nullptr) {
+  // Initialize ScubaLogger and ScubaData
+  scubaLogger_ = std::make_unique<facebook::glean::swift::ScubaLogger>();
+  scubaData_ = std::make_unique<facebook::rfe::ScubaData>("swift_glass_client");
+}
 
 void JsonServer::setGlassAccess(std::unique_ptr<IGlassAccess> glassAccess) {
   glassAccess_ = std::move(glassAccess);
@@ -33,6 +38,8 @@ void JsonServer::stop() {
 void JsonServer::processRequest(
     const std::string& requestStr,
     std::ostream& output) {
+  facebook::glean::swift::Clock clock;
+
   try {
     auto request = folly::parseJson(requestStr);
 
@@ -45,72 +52,149 @@ void JsonServer::processRequest(
       handleUSRToDefinitionRequest(id, value, output);
     } else {
       // Send error response for unknown method
-      sendErrorResponse(id, -32601, "Method not found", output);
+      auto duration = clock.duration();
+      sendErrorResponse(
+          id,
+          -32601,
+          "Method not found",
+          output,
+          method,
+          value,
+          determineUSRType(value),
+          duration);
     }
   } catch (const std::exception& e) {
-    // Send parse error response
+    // Send parse error response - no method/usr available due to parsing error
+    auto duration = clock.duration();
     sendErrorResponse(
         folly::dynamic::object,
         -32700,
         "Parse error: " + std::string(e.what()),
-        output);
+        output,
+        std::nullopt,
+        std::nullopt,
+        std::nullopt,
+        duration);
   }
 }
 
 void JsonServer::handleUSRToDefinitionRequest(
     const folly::dynamic& id,
     const std::string& usr,
     std::ostream& output) {
+  // Start timing for scuba logging
+  facebook::glean::swift::Clock clock;
+
   if (!glassAccess_) {
+    auto duration = clock.duration();
     sendErrorResponse(
-        id, -32603, "Internal error: GlassAccess not initialized", output);
+        id,
+        -32603,
+        "Internal error: GlassAccess not initialized",
+        output,
+        "USRToDefinition",
+        usr,
+        determineUSRType(usr),
+        duration);
     return;
   }
 
-  // Call GlassAccess to get definition locations
-  auto locations = glassAccess_->usrToDefinition(usr);
+  // Determine USR type and method
+  facebook::glean::swift::USRType usrType = determineUSRType(usr);
+  std::string method = (usrType == facebook::glean::swift::USRType::SWIFT)
+      ? "usrToDefinition"
+      : "clangUSRToDefinition";
 
-  // Create response
-  folly::dynamic response = folly::dynamic::object;
-  response["id"] = id;
+  facebook::glean::swift::Status status =
+      facebook::glean::swift::Status::FAILED;
+  std::string error;
 
-  if (locations.has_value()) {
-    // Convert protocol::Location objects to JSON
-    folly::dynamic result = folly::dynamic::array;
-    for (const auto& location : locations.value()) {
-      folly::dynamic locationJson = folly::dynamic::object;
-      locationJson["uri"] = location.uri;
+  try {
+    // Call GlassAccess to get definition locations
+    auto locations = glassAccess_->usrToDefinition(usr);
+
+    // Create response
+    folly::dynamic response = folly::dynamic::object;
+    response["id"] = id;
+
+    if (locations.has_value() && !locations->empty()) {
+      // Convert protocol::Location objects to JSON
+      folly::dynamic result = folly::dynamic::array;
+      for (const auto& location : locations.value()) {
+        folly::dynamic locationJson = folly::dynamic::object;
+        locationJson["uri"] = location.uri;
+
+        folly::dynamic range = folly::dynamic::object;
+        folly::dynamic start = folly::dynamic::object;
+        start["line"] = location.range.start.line;
+        start["character"] = location.range.start.character;
+
+        folly::dynamic end = folly::dynamic::object;
+        end["line"] = location.range.end.line;
+        end["character"] = location.range.end.character;
+
+        range["start"] = start;
+        range["end"] = end;
+        locationJson["range"] = range;
+
+        result.push_back(locationJson);
+      }
+      response["result"] = result;
+      status = facebook::glean::swift::Status::SUCCESS;
+    } else {
+      // No definitions found, return empty array
+      response["result"] = folly::dynamic::array;
+      status = facebook::glean::swift::Status::NOT_FOUND;
+    }
 
-      folly::dynamic range = folly::dynamic::object;
-      folly::dynamic start = folly::dynamic::object;
-      start["line"] = location.range.start.line;
-      start["character"] = location.range.start.character;
+    // Calculate duration and log the request
+    auto duration = clock.duration();
 
-      folly::dynamic end = folly::dynamic::object;
-      end["line"] = location.range.end.line;
-      end["character"] = location.range.end.character;
+    // Use folly::toJson(response) to get the result string for logging
+    std::string resultStr = folly::toJson(response["result"]);
 
-      range["start"] = start;
-      range["end"] = end;
-      locationJson["range"] = range;
+    // Log the request to Scuba
+    scubaLogger_->logRequest(
+        scubaData_.get(),
+        method,
+        usr,
+        usrType,
+        resultStr,
+        status,
+        duration,
+        error,
+        std::nullopt);
 
-      result.push_back(locationJson);
-    }
-    response["result"] = result;
-  } else {
-    // No definitions found, return empty array
-    response["result"] = folly::dynamic::array;
-  }
+    // Send response
+    output << folly::toJson(response) << "\n";
 
-  // Send response
-  output << folly::toJson(response) << "\n";
+  } catch (const std::exception& e) {
+    error = e.what();
+
+    // Calculate duration and log the failed request
+    auto duration = clock.duration();
+
+    sendErrorResponse(
+        id,
+        -32603,
+        "Internal error: " + error,
+        output,
+        method,
+        usr,
+        usrType,
+        duration);
+  }
 }
 
 void JsonServer::sendErrorResponse(
     const folly::dynamic& id,
     int code,
     const std::string& message,
-    std::ostream& output) {
+    std::ostream& output,
+    const std::optional<std::string>& method,
+    const std::optional<std::string>& usr,
+    const std::optional<facebook::glean::swift::USRType>& usrType,
+    int64_t duration) {
   folly::dynamic response = folly::dynamic::object;
   response["id"] = id;
 
@@ -120,4 +204,29 @@ void JsonServer::sendErrorResponse(
   response["error"] = error;
 
   output << folly::toJson(response) << "\n";
+
+  // Log error to Scuba
+  if (scubaLogger_ && scubaData_) {
+    scubaLogger_->logRequest(
+        scubaData_.get(),
+        method.value_or("unknown"),
+        usr.value_or(""),
+        usrType.value_or(facebook::glean::swift::USRType::UNKNOWN),
+        "[]",
+        facebook::glean::swift::Status::FAILED,
+        duration,
+        message,
+        std::nullopt);
+  }
+}
+
+facebook::glean::swift::USRType JsonServer::determineUSRType(
+    const std::string& usr) {
+  if (usr.length() >= 2 && usr.substr(0, 2) == "s:") {
+    return facebook::glean::swift::USRType::SWIFT;
+  } else if (usr.length() >= 2 && usr.substr(0, 2) == "c:") {
+    return facebook::glean::swift::USRType::CPP;
+  } else {
+    return facebook::glean::swift::USRType::UNKNOWN;
+  }
 }

glean/client/swift/JsonServer.h

@@ -14,6 +14,8 @@
 #include <iostream>
 #include <memory>
 #include "glean/client/swift/IGlassAccess.h"
+#include "glean/client/swift/ScubaLogger.h"
+#include "rfe/scubadata/ScubaData.h"
 
 class JsonServer {
  public:
@@ -36,6 +38,9 @@ class JsonServer {
   FRIEND_TEST(JsonServerTest, InvalidJSONRequest);
   std::atomic<bool> running_;
   std::unique_ptr<IGlassAccess> glassAccess_;
+  std::unique_ptr<facebook::glean::swift::ScubaLogger> scubaLogger_;
+  std::unique_ptr<facebook::rfe::ScubaData> scubaData_;
+
   void handleUSRToDefinitionRequest(
       const folly::dynamic& id,
       const std::string& usr,
@@ -44,5 +49,12 @@ class JsonServer {
       const folly::dynamic& id,
       int code,
       const std::string& message,
-      std::ostream& output);
+      std::ostream& output,
+      const std::optional<std::string>& method = std::nullopt,
+      const std::optional<std::string>& usr = std::nullopt,
+      const std::optional<facebook::glean::swift::USRType>& usrType =
+          std::nullopt,
+      int64_t duration = 0);
+
+  facebook::glean::swift::USRType determineUSRType(const std::string& usr);
 };

glean/client/swift/ScubaLogger.cpp

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "glean/client/swift/ScubaLogger.h"
+#include <glog/logging.h>
+#include <cstdlib>
+
+namespace facebook::glean::swift {
+
+ScubaLogger::ScubaLogger()
+    : unixname_(std::getenv("USER") ? std::getenv("USER") : "unknown"),
+      hostmachine_(boost::asio::ip::host_name()) {}
+
+void ScubaLogger::logRequest(
+    facebook::rfe::ScubaData* scubaLogger,
+    const std::string& method,
+    const std::string& usr,
+    USRType usrType,
+    const std::string& result,
+    Status status,
+    int64_t duration,
+    const std::string& error,
+    const std::optional<std::string>& revision) {
+  if (!scubaLogger) {
+    return;
+  }
+
+  facebook::rfe::ScubaDataSample sample;
+  sample.setTimeColumnNow();
+
+  // Core request information
+  sample.addNormalValue("method", method);
+  sample.addNormalValue("usr", usr);
+  sample.addNormalValue("usr_type", usrTypeToString(usrType));
+  sample.addNormalValue("result", result);
+  sample.addNormalValue("status", statusToString(status));
+  sample.addNormalValue("error", error);
+
+  // Environment information
+  sample.addNormalValue("unixname", unixname_);
+  sample.addNormalValue("hostmachine", hostmachine_);
+
+  // Timing and status
+  sample.addIntValue("time_taken_ms", duration);
+  sample.addIntValue("result_size", static_cast<int64_t>(result.length()));
+  sample.addIntValue("usr_length", static_cast<int64_t>(usr.length()));
+
+  // Optional revision information
+  if (revision.has_value()) {
+    sample.addNormalValue("revision", revision.value());
+  }
+
+  // Add sample to scuba
+  scubaLogger->addSample("swift_glass_client", sample);
+
+  // Log to console for debugging
+  LOG(INFO) << "Request - method: " << method
+            << " usr_type: " << usrTypeToString(usrType)
+            << " status: " << statusToString(status) << " time: " << duration
+            << "ms" << " result_size: " << result.length()
+            << (error.empty() ? "" : " error: " + error);
+}
+
+std::string ScubaLogger::usrTypeToString(USRType type) const {
+  switch (type) {
+    case USRType::SWIFT:
+      return "swift";
+    case USRType::CPP:
+      return "cpp";
+    case USRType::UNKNOWN:
+      return "unknown";
+    default:
+      return "invalid";
+  }
+}
+
+std::string ScubaLogger::statusToString(Status status) const {
+  switch (status) {
+    case Status::SUCCESS:
+      return "success";
+    case Status::FAILED:
+      return "failed";
+    case Status::TIMEOUT:
+      return "timeout";
+    case Status::NOT_FOUND:
+      return "not_found";
+    default:
+      return "invalid";
+  }
+}
+
+} // namespace facebook::glean::swift