Add the client name and ipport to the slowlog output

src/server/redis_connection.cc

@@ -416,7 +416,7 @@ void Connection::ExecuteCommands(std::deque<CommandTokens> *to_process_cmds) {
     uint64_t duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
     if (is_profiling) RecordProfilingSampleIfNeed(cmd_name, duration);
 
-    svr_->SlowlogPushEntryIfNeeded(&cmd_tokens, duration);
+    svr_->SlowlogPushEntryIfNeeded(&cmd_tokens, duration, this->name_, this->ip_, this->port_);
     svr_->stats.IncrLatency(static_cast<uint64_t>(duration), cmd_name);
     svr_->FeedMonitorConns(this, cmd_tokens);
 

src/server/server.cc

@@ -1407,7 +1407,8 @@ time_t Server::GetLastScanTime(const std::string &ns) {
   return 0;
 }
 
-void Server::SlowlogPushEntryIfNeeded(const std::vector<std::string> *args, uint64_t duration) {
+void Server::SlowlogPushEntryIfNeeded(const std::vector<std::string> *args, uint64_t duration, std::string client_name,
+                                      std::string ip, uint32_t port) {
   int64_t threshold = config_->slowlog_log_slower_than;
   if (threshold < 0 || static_cast<int64_t>(duration) < threshold) return;
 
@@ -1428,6 +1429,9 @@ void Server::SlowlogPushEntryIfNeeded(const std::vector<std::string> *args, uint
   }
 
   entry->duration = duration;
+  entry->client_name = std::move(client_name);
+  entry->ip = std::move(ip);
+  entry->port = port;
   slow_log_.PushEntry(std::move(entry));
 }
 

src/server/server.h

@@ -264,7 +264,8 @@ class Server {
 
   LogCollector<PerfEntry> *GetPerfLog() { return &perf_log_; }
   LogCollector<SlowEntry> *GetSlowLog() { return &slow_log_; }
-  void SlowlogPushEntryIfNeeded(const std::vector<std::string> *args, uint64_t duration);
+  void SlowlogPushEntryIfNeeded(const std::vector<std::string> *args, uint64_t duration, std::string client_name,
+                                std::string ip, uint32_t port);
 
   std::shared_lock<std::shared_mutex> WorkConcurrencyGuard();
   std::unique_lock<std::shared_mutex> WorkExclusivityGuard();

src/stats/log_collector.cc

@@ -21,17 +21,20 @@
 #include "log_collector.h"
 
 #include <algorithm>
+#include <string>
 
 #include "server/redis_reply.h"
 #include "time_util.h"
 
 std::string SlowEntry::ToRedisString() const {
   std::string output;
-  output.append(redis::MultiLen(4));
+  output.append(redis::MultiLen(6));
   output.append(redis::Integer(id));
   output.append(redis::Integer(time));
   output.append(redis::Integer(duration));
   output.append(redis::MultiBulkString(args));
+  output.append(redis::BulkString(ip + ":" + std::to_string(port)));
+  output.append(redis::BulkString(client_name));
   return output;
 }
 

src/stats/log_collector.h

@@ -20,6 +20,7 @@
 
 #pragma once
 
+#include <sys/types.h>
 #include <time.h>
 
 #include <cstdint>
@@ -36,7 +37,9 @@ class SlowEntry {
   time_t time;
   uint64_t duration;
   std::vector<std::string> args;
-
+  std::string client_name;
+  std::string ip;
+  uint32_t port;
   std::string ToRedisString() const;
 };
 

src/storage/scripting.cc

@@ -406,7 +406,7 @@ int RedisGenericCommand(lua_State *lua, int raise_error) {
   auto end = std::chrono::high_resolution_clock::now();
   uint64_t duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
   if (is_profiling) conn->RecordProfilingSampleIfNeed(cmd_name, duration);
-  srv->SlowlogPushEntryIfNeeded(&args, duration);
+  srv->SlowlogPushEntryIfNeeded(&args, duration, conn->GetName(), conn->GetIP(), conn->GetPort());
   srv->stats.IncrLatency(static_cast<uint64_t>(duration), cmd_name);
   srv->FeedMonitorConns(conn, args);
   if (!s) {