Optimize log format, fix typo

Author: matyhtf

ext-src/php_swoole.cc

@@ -688,7 +688,7 @@ PHP_MINIT_FUNCTION(swoole) {
     SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_EOF_PROTOCOL", SW_TRACE_EOF_PROTOCOL);
     SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_LENGTH_PROTOCOL", SW_TRACE_LENGTH_PROTOCOL);
     SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_CLOSE", SW_TRACE_CLOSE);
-    SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_WEBSOCEKT", SW_TRACE_WEBSOCEKT);
+    SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_WEBSOCKET", SW_TRACE_WEBSOCKET);
     SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_REDIS_CLIENT", SW_TRACE_REDIS_CLIENT);
     SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_MYSQL_CLIENT", SW_TRACE_MYSQL_CLIENT);
     SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_HTTP_CLIENT", SW_TRACE_HTTP_CLIENT);

include/swoole_log.h

@@ -116,7 +116,7 @@ swoole::Logger *sw_logger();
 #define swWarn(str, ...)                                                                                               \
     do {                                                                                                               \
         if (SW_LOG_WARNING >= sw_logger()->get_level()) {                                                              \
-            size_t _sw_error_len = sw_snprintf(sw_error, SW_ERROR_MSG_SIZE, "%s: " str, __func__, ##__VA_ARGS__);      \
+            size_t _sw_error_len = sw_snprintf(sw_error, SW_ERROR_MSG_SIZE, str, ##__VA_ARGS__);                       \
             sw_logger()->put(SW_LOG_WARNING, sw_error, _sw_error_len);                                                 \
         }                                                                                                              \
     } while (0)
@@ -169,7 +169,7 @@ swoole::Logger *sw_logger();
         swoole_set_last_error(__errno);                                                                                \
         if (level >= sw_logger()->get_level()) {                                                                       \
             size_t _sw_error_len =                                                                                     \
-                sw_snprintf(sw_error, SW_ERROR_MSG_SIZE, "%s (ERRNO %d): " str, __func__, __errno, ##__VA_ARGS__);     \
+                sw_snprintf(sw_error, SW_ERROR_MSG_SIZE, "(ERRNO %d): " str, __errno, ##__VA_ARGS__);                  \
             sw_logger()->put(level, sw_error, _sw_error_len);                                                          \
         }                                                                                                              \
     } while (0)
@@ -222,7 +222,7 @@ enum swTrace_type {
     SW_TRACE_EOF_PROTOCOL = 1u << 12,
     SW_TRACE_LENGTH_PROTOCOL = 1u << 13,
     SW_TRACE_CLOSE = 1u << 14,
-    SW_TRACE_WEBSOCEKT = 1u << 15,
+    SW_TRACE_WEBSOCKET = 1u << 15,
     /**
      * Client
      */

src/coroutine/socket.cc

@@ -1486,7 +1486,13 @@ ssize_t Socket::recv_packet_with_length_protocol() {
         goto _recv_header;
     } else if (packet_len > protocol.package_max_length) {
         read_buffer->clear();
-        set_err(SW_ERROR_PACKAGE_LENGTH_TOO_LARGE, "remote packet is too big");
+        swoole_error_log(SW_LOG_WARNING,
+                            SW_ERROR_PACKAGE_LENGTH_TOO_LARGE,
+                            "packet length is too big, remote_addr=%s:%d, length=%zu",
+                            socket->info.get_ip(),
+                            socket->info.get_port(),
+                            packet_len);
+        set_err(SW_ERROR_PACKAGE_LENGTH_TOO_LARGE, sw_error);
         return -1;
     }
 

src/protocol/websocket.cc

@@ -180,6 +180,12 @@ bool decode(Frame *frame, char *data, size_t length) {
         header_length += 8;
     }
 
+    swTraceLog(SW_TRACE_WEBSOCKET,
+               "decode frame, payload_length=%ld, mask=%d, opcode=%d",
+               payload_length,
+               frame->header.MASK,
+               frame->header.OPCODE);
+
     if (payload_length == 0) {
         frame->header_length = header_length;
         frame->payload_length = 0;

src/server/master.cc

@@ -1004,13 +1004,13 @@ int Server::send_to_connection(SendData *_send) {
         if (_send->info.type == SW_SERVER_EVENT_RECV_DATA) {
             swoole_error_log(SW_LOG_NOTICE,
                              SW_ERROR_SESSION_NOT_EXIST,
-                             "send %d byte failed, session#%ld does not exist",
+                             "Server::send(): send %d byte failed, session#%ld does not exist",
                              _send_length,
                              session_id);
         } else {
             swoole_error_log(SW_LOG_NOTICE,
                              SW_ERROR_SESSION_NOT_EXIST,
-                             "send event[%d] failed, session#%ld does not exist",
+                             "Server::send(): send event[%d] failed, session#%ld does not exist",
                              _send->info.type,
                              session_id);
         }
@@ -1129,16 +1129,19 @@ int Server::send_to_connection(SendData *_send) {
     else {
         // connection is closed
         if (conn->peer_closed) {
-            swWarn("connection#%d is closed by client", fd);
+            swoole_error_log(
+                SW_LOG_NOTICE, SW_ERROR_SESSION_CLOSED_BY_CLIENT, "Server::send(): socket#%d is closed by client", fd);
             return false;
         }
         // connection output buffer overflow
         if (_socket->out_buffer->length() >= _socket->buffer_size) {
             if (send_yield) {
                 swoole_set_last_error(SW_ERROR_OUTPUT_SEND_YIELD);
             } else {
-                swoole_error_log(
-                    SW_LOG_WARNING, SW_ERROR_OUTPUT_BUFFER_OVERFLOW, "connection#%d output buffer overflow", fd);
+                swoole_error_log(SW_LOG_WARNING,
+                                 SW_ERROR_OUTPUT_BUFFER_OVERFLOW,
+                                 "Server::send(): connection#%d output buffer overflow",
+                                 fd);
             }
             conn->overflow = 1;
             if (onBufferEmpty && onBufferFull == nullptr) {