@clickhouse/client 1.16.0 → 1.18.0

package/dist/connection/node_base_connection.js

@@ -12,55 +12,31 @@ const utils_1 = require("../utils");
 const compression_1 = require("./compression");
 const stream_2 = require("./stream");
 class NodeBaseConnection {
+    params;
+    agent;
+    defaultAuthHeader;
+    defaultHeaders;
+    jsonHandling;
+    knownSockets = new WeakMap();
+    idleSocketTTL;
+    connectionId = crypto_1.default.randomUUID();
+    socketCounter = 0;
+    // For overflow concerns:
+    //   node -e 'console.log(Number.MAX_SAFE_INTEGER / (1_000_000 * 60 * 60 * 24 * 366))'
+    // gives 284 years of continuous operation at 1M requests per second
+    // before overflowing the 53-bit integer
+    requestCounter = 0;
+    getNewSocketId() {
+        this.socketCounter += 1;
+        return `${this.connectionId}:${this.socketCounter}`;
+    }
+    getNewRequestId() {
+        this.requestCounter += 1;
+        return `${this.connectionId}:${this.requestCounter}`;
+    }
     constructor(params, agent) {
-        Object.defineProperty(this, "params", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: params
-        });
-        Object.defineProperty(this, "agent", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: agent
-        });
-        Object.defineProperty(this, "defaultAuthHeader", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "defaultHeaders", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "jsonHandling", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "logger", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "knownSockets", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new WeakMap()
-        });
-        Object.defineProperty(this, "idleSocketTTL", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
+        this.params = params;
+        this.agent = agent;
         if (params.auth.type === 'Credentials') {
             this.defaultAuthHeader = `Basic ${Buffer.from(`${params.auth.username}:${params.auth.password}`).toString('base64')}`;
         }
@@ -75,7 +51,6 @@ class NodeBaseConnection {
             Connection: this.params.keep_alive.enabled ? 'keep-alive' : 'close',
             'User-Agent': (0, utils_1.getUserAgent)(this.params.application_id),
         };
-        this.logger = params.log_writer;
         this.idleSocketTTL = params.keep_alive.idle_socket_ttl;
         this.jsonHandling = params.json ?? {
             parse: JSON.parse,
@@ -83,6 +58,7 @@ class NodeBaseConnection {
         };
     }
     async ping(params) {
+        const { log_writer, log_level } = this.params;
         const query_id = this.getQueryId(params.query_id);
         const { controller, controllerCleanup } = this.getAbortController(params);
         let result;
@@ -99,6 +75,9 @@ class NodeBaseConnection {
                     query: PingQuery,
                     abort_signal: controller.signal,
                     headers: this.buildRequestHeaders(),
+                    query_id,
+                    log_writer,
+                    log_level,
                 }, 'Ping');
             }
             else {
@@ -108,9 +87,17 @@ class NodeBaseConnection {
                     abort_signal: controller.signal,
                     headers: this.buildRequestHeaders(),
                     query: 'ping',
+                    query_id,
+                    log_writer,
+                    log_level,
                 }, 'Ping');
             }
-            await (0, stream_2.drainStream)(result.stream);
+            await (0, stream_2.drainStream)({
+                op: 'Ping',
+                log_writer,
+                query_id,
+                log_level,
+            }, result.stream);
             return { success: true };
         }
         catch (error) {
@@ -118,13 +105,16 @@ class NodeBaseConnection {
             // and we don't get unhandled error propagation later
             controller.abort('Ping failed');
             // not an error, as this might be semi-expected
-            this.logger.warn({
-                message: this.httpRequestErrorMessage('Ping'),
-                err: error,
-                args: {
-                    query_id,
-                },
-            });
+            if (log_level <= client_common_1.ClickHouseLogLevel.WARN) {
+                log_writer.warn({
+                    message: this.httpRequestErrorMessage('Ping'),
+                    err: error,
+                    args: {
+                        connection_id: this.connectionId,
+                        query_id,
+                    },
+                });
+            }
             return {
                 success: false,
                 error: error, // should NOT be propagated to the user
@@ -135,6 +125,7 @@ class NodeBaseConnection {
         }
     }
     async query(params) {
+        const { log_writer, log_level } = this.params;
         const query_id = this.getQueryId(params.query_id);
         const clickhouse_settings = (0, client_common_1.withHttpSettings)(params.clickhouse_settings, this.params.compression.decompress_response);
         const searchParams = (0, client_common_1.toSearchParams)({
@@ -149,7 +140,7 @@ class NodeBaseConnection {
         // allows enforcing the compression via the settings even if the client instance has it disabled
         const enableResponseCompression = clickhouse_settings.enable_http_compression === 1;
         try {
-            const { response_headers, stream } = await this.request({
+            const { response_headers, stream, http_status_code } = await this.request({
                 method: 'POST',
                 url: (0, client_common_1.transformUrl)({ url: this.params.url, searchParams }),
                 body: params.query,
@@ -157,11 +148,15 @@ class NodeBaseConnection {
                 enable_response_compression: enableResponseCompression,
                 headers: this.buildRequestHeaders(params),
                 query: params.query,
+                query_id,
+                log_writer,
+                log_level,
             }, 'Query');
             return {
                 stream,
                 response_headers,
                 query_id,
+                http_status_code,
             };
         }
         catch (err) {
@@ -184,6 +179,7 @@ class NodeBaseConnection {
         }
     }
     async insert(params) {
+        const { log_writer, log_level } = this.params;
         const query_id = this.getQueryId(params.query_id);
         const searchParams = (0, client_common_1.toSearchParams)({
             database: this.params.database,
@@ -196,7 +192,7 @@ class NodeBaseConnection {
         });
         const { controller, controllerCleanup } = this.getAbortController(params);
         try {
-            const { stream, summary, response_headers } = await this.request({
+            const { stream, summary, response_headers, http_status_code } = await this.request({
                 method: 'POST',
                 url: (0, client_common_1.transformUrl)({ url: this.params.url, searchParams }),
                 body: params.values,
@@ -205,9 +201,17 @@ class NodeBaseConnection {
                 parse_summary: true,
                 headers: this.buildRequestHeaders(params),
                 query: params.query,
+                query_id,
+                log_writer,
+                log_level,
             }, 'Insert');
-            await (0, stream_2.drainStream)(stream);
-            return { query_id, summary, response_headers };
+            await (0, stream_2.drainStream)({
+                op: 'Insert',
+                log_writer,
+                query_id,
+                log_level,
+            }, stream);
+            return { query_id, summary, response_headers, http_status_code };
         }
         catch (err) {
             controller.abort('Insert HTTP request failed');
@@ -228,18 +232,74 @@ class NodeBaseConnection {
         }
     }
     async exec(params) {
+        const query_id = this.getQueryId(params.query_id);
         return this.runExec({
             ...params,
+            query_id,
             op: 'Exec',
         });
     }
     async command(params) {
-        const { stream, query_id, summary, response_headers } = await this.runExec({
+        const { log_writer, log_level } = this.params;
+        const query_id = this.getQueryId(params.query_id);
+        const commandStartTime = Date.now();
+        if (log_level <= client_common_1.ClickHouseLogLevel.TRACE) {
+            log_writer.trace({
+                message: 'Command: operation started',
+                args: {
+                    operation: 'Command',
+                    connection_id: this.connectionId,
+                    query_id,
+                    query: this.params.unsafeLogUnredactedQueries
+                        ? params.query
+                        : undefined,
+                },
+            });
+        }
+        const { stream, summary, response_headers } = await this.runExec({
             ...params,
+            query_id,
             op: 'Command',
         });
+        const runExecDuration = Date.now() - commandStartTime;
+        if (log_level <= client_common_1.ClickHouseLogLevel.TRACE) {
+            log_writer.trace({
+                message: 'Command: runExec completed, starting stream drain',
+                args: {
+                    operation: 'Command',
+                    connection_id: this.connectionId,
+                    query_id,
+                    runExec_duration_ms: runExecDuration,
+                    stream_state: {
+                        readable: stream.readable,
+                        readableEnded: stream.readableEnded,
+                        readableLength: stream.readableLength,
+                    },
+                },
+            });
+        }
         // ignore the response stream and release the socket immediately
-        await (0, stream_2.drainStream)(stream);
+        const drainStartTime = Date.now();
+        await (0, stream_2.drainStream)({
+            op: 'Command',
+            log_writer,
+            query_id,
+            log_level,
+        }, stream);
+        if (log_level <= client_common_1.ClickHouseLogLevel.TRACE) {
+            const drainDuration = Date.now() - drainStartTime;
+            const totalDuration = Date.now() - commandStartTime;
+            log_writer.trace({
+                message: 'Command: operation completed',
+                args: {
+                    operation: 'Command',
+                    connection_id: this.connectionId,
+                    query_id,
+                    drain_duration_ms: drainDuration,
+                    total_duration_ms: totalDuration,
+                },
+            });
+        }
         return { query_id, summary, response_headers };
     }
     async close() {
@@ -302,37 +362,31 @@ class NodeBaseConnection {
             },
         };
     }
-    logResponse(op, request, params, response, startTimestamp) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { authorization, host, ...headers } = request.getHeaders();
-        const duration = Date.now() - startTimestamp;
-        this.params.log_writer.debug({
-            module: 'HTTP Adapter',
-            message: `${op}: got a response from ClickHouse`,
-            args: {
-                request_method: params.method,
-                request_path: params.url.pathname,
-                request_params: params.url.search,
-                request_headers: headers,
-                response_status: response.statusCode,
-                response_headers: response.headers,
-                response_time_ms: duration,
-            },
-        });
-    }
     logRequestError({ op, err, query_id, query_params, search_params, extra_args, }) {
-        this.logger.error({
-            message: this.httpRequestErrorMessage(op),
-            err: err,
-            args: {
-                query: query_params.query,
-                search_params: search_params?.toString() ?? '',
-                with_abort_signal: query_params.abort_signal !== undefined,
-                session_id: query_params.session_id,
-                query_id: query_id,
-                ...extra_args,
-            },
-        });
+        if (this.params.log_level <= client_common_1.ClickHouseLogLevel.ERROR) {
+            // Redact query parameter from search params unless explicitly allowed
+            if (!this.params.unsafeLogUnredactedQueries && search_params) {
+                // Clone to avoid mutating the original search params
+                search_params = new URLSearchParams(search_params);
+                search_params.delete('query');
+            }
+            this.params.log_writer.error({
+                message: this.httpRequestErrorMessage(op),
+                err: err,
+                args: {
+                    operation: op,
+                    connection_id: this.connectionId,
+                    query_id,
+                    query: this.params.unsafeLogUnredactedQueries
+                        ? query_params.query
+                        : undefined,
+                    search_params: search_params?.toString(),
+                    with_abort_signal: query_params.abort_signal !== undefined,
+                    session_id: query_params.session_id,
+                    ...extra_args,
+                },
+            });
+        }
     }
     httpRequestErrorMessage(op) {
         return `${op}: HTTP request error.`;
@@ -344,18 +398,23 @@ class NodeBaseConnection {
                 return this.jsonHandling.parse(summaryHeader);
             }
             catch (err) {
-                this.logger.error({
-                    message: `${op}: failed to parse X-ClickHouse-Summary header.`,
-                    args: {
-                        'X-ClickHouse-Summary': summaryHeader,
-                    },
-                    err: err,
-                });
+                if (this.params.log_level <= client_common_1.ClickHouseLogLevel.ERROR) {
+                    this.params.log_writer.error({
+                        message: `${op}: failed to parse X-ClickHouse-Summary header.`,
+                        args: {
+                            operation: op,
+                            connection_id: this.connectionId,
+                            'X-ClickHouse-Summary': summaryHeader,
+                        },
+                        err: err,
+                    });
+                }
             }
         }
     }
     async runExec(params) {
-        const query_id = this.getQueryId(params.query_id);
+        const { log_writer, log_level } = this.params;
+        const query_id = params.query_id;
         const sendQueryInParams = params.values !== undefined;
         const clickhouse_settings = (0, client_common_1.withHttpSettings)(params.clickhouse_settings, this.params.compression.decompress_response);
         const toSearchParamsOptions = {
@@ -378,7 +437,7 @@ class NodeBaseConnection {
                 false;
         const ignoreErrorResponse = params.ignore_error_response ?? false;
         try {
-            const { stream, summary, response_headers } = await this.request({
+            const { stream, summary, response_headers, http_status_code } = await this.request({
                 method: 'POST',
                 url: (0, client_common_1.transformUrl)({ url: this.params.url, searchParams }),
                 body: sendQueryInParams ? params.values : params.query,
@@ -390,12 +449,16 @@ class NodeBaseConnection {
                 ignore_error_response: ignoreErrorResponse,
                 headers: this.buildRequestHeaders(params),
                 query: params.query,
+                query_id,
+                log_writer,
+                log_level,
             }, params.op);
             return {
                 stream,
                 query_id,
                 summary,
                 response_headers,
+                http_status_code,
             };
         }
         catch (err) {
@@ -420,13 +483,15 @@ class NodeBaseConnection {
         // allows the event loop to process the idle socket timers, if the CPU load is high
         // otherwise, we can occasionally get an expired socket, see https://github.com/ClickHouse/clickhouse-js/issues/294
         await (0, client_common_1.sleep)(0);
+        const { log_writer, query_id, log_level } = params;
         const currentStackTrace = this.params.capture_enhanced_stack_trace
             ? (0, client_common_1.getCurrentStackTrace)()
             : undefined;
-        const logger = this.logger;
+        const requestTimeout = this.params.request_timeout;
         return new Promise((resolve, reject) => {
             const start = Date.now();
             const request = this.createClientRequest(params);
+            const request_id = this.getNewRequestId();
             function onError(e) {
                 removeRequestListeners();
                 const err = (0, client_common_1.enhanceStackTrace)(e, currentStackTrace);
@@ -434,14 +499,42 @@ class NodeBaseConnection {
             }
             let responseStream;
             const onResponse = async (_response) => {
-                this.logResponse(op, request, params, _response, start);
+                if (this.params.log_level <= client_common_1.ClickHouseLogLevel.DEBUG) {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const { authorization, host, ...headers } = request.getHeaders();
+                    const duration = Date.now() - start;
+                    // Redact query parameter from URL search params unless explicitly allowed
+                    let searchParams = params.url.searchParams;
+                    if (!this.params.unsafeLogUnredactedQueries) {
+                        // Clone to avoid mutating the original search params
+                        searchParams = new URLSearchParams(searchParams);
+                        searchParams.delete('query');
+                    }
+                    this.params.log_writer.debug({
+                        module: 'HTTP Adapter',
+                        message: `${op}: got a response from ClickHouse`,
+                        args: {
+                            operation: op,
+                            connection_id: this.connectionId,
+                            query_id,
+                            request_id,
+                            request_method: params.method,
+                            request_path: params.url.pathname,
+                            request_params: searchParams.toString(),
+                            request_headers: headers,
+                            response_status: _response.statusCode,
+                            response_headers: _response.headers,
+                            response_time_ms: duration,
+                        },
+                    });
+                }
                 const tryDecompressResponseStream = params.try_decompress_response_stream ?? true;
                 const ignoreErrorResponse = params.ignore_error_response ?? false;
                 // even if the stream decompression is disabled, we have to decompress it in case of an error
                 const isFailedResponse = !(0, client_common_1.isSuccessfulResponse)(_response.statusCode);
                 if (tryDecompressResponseStream ||
                     (isFailedResponse && !ignoreErrorResponse)) {
-                    const decompressionResult = (0, compression_1.decompressResponse)(_response, this.logger);
+                    const decompressionResult = (0, compression_1.decompressResponse)(_response, log_writer, log_level);
                     if ((0, compression_1.isDecompressionError)(decompressionResult)) {
                         const err = (0, client_common_1.enhanceStackTrace)(decompressionResult.error, currentStackTrace);
                         return reject(err);
@@ -451,6 +544,24 @@ class NodeBaseConnection {
                 else {
                     responseStream = _response;
                 }
+                if (log_level <= client_common_1.ClickHouseLogLevel.TRACE) {
+                    log_writer.trace({
+                        message: `${op}: response stream created`,
+                        args: {
+                            operation: op,
+                            connection_id: this.connectionId,
+                            query_id,
+                            request_id,
+                            stream_state: {
+                                readable: responseStream.readable,
+                                readableEnded: responseStream.readableEnded,
+                                readableLength: responseStream.readableLength,
+                            },
+                            is_failed_response: isFailedResponse,
+                            will_decompress: tryDecompressResponseStream,
+                        },
+                    });
+                }
                 if (isFailedResponse && !ignoreErrorResponse) {
                     try {
                         const errorMessage = await (0, utils_1.getAsText)(responseStream);
@@ -470,6 +581,7 @@ class NodeBaseConnection {
                             ? this.parseSummary(op, _response)
                             : undefined,
                         response_headers: { ..._response.headers },
+                        http_status_code: _response.statusCode ?? undefined,
                     });
                 }
             };
@@ -522,96 +634,229 @@ class NodeBaseConnection {
                         // It is the first time we've encountered this socket,
                         // so it doesn't have the idle timeout handler attached to it
                         if (socketInfo === undefined) {
-                            const socketId = crypto_1.default.randomUUID();
-                            this.logger.trace({
-                                message: `Using a fresh socket ${socketId}, setting up a new 'free' listener`,
-                            });
-                            this.knownSockets.set(socket, {
-                                id: socketId,
+                            const socket_id = this.getNewSocketId();
+                            if (log_level <= client_common_1.ClickHouseLogLevel.TRACE) {
+                                log_writer.trace({
+                                    message: `${op}: using a fresh socket, setting up a new 'free' listener`,
+                                    args: {
+                                        operation: op,
+                                        connection_id: this.connectionId,
+                                        query_id,
+                                        request_id,
+                                        socket_id,
+                                    },
+                                });
+                            }
+                            const newSocketInfo = {
+                                id: socket_id,
                                 idle_timeout_handle: undefined,
-                            });
+                                usage_count: 1,
+                            };
+                            this.knownSockets.set(socket, newSocketInfo);
                             // When the request is complete and the socket is released,
                             // make sure that the socket is removed after `idleSocketTTL`.
                             socket.on('free', () => {
-                                this.logger.trace({
-                                    message: `Socket ${socketId} was released`,
-                                });
+                                if (log_level <= client_common_1.ClickHouseLogLevel.TRACE) {
+                                    log_writer.trace({
+                                        message: `${op}: socket was released`,
+                                        args: {
+                                            operation: op,
+                                            connection_id: this.connectionId,
+                                            query_id,
+                                            request_id,
+                                            socket_id,
+                                        },
+                                    });
+                                }
                                 // Avoiding the built-in socket.timeout() method usage here,
                                 // as we don't want to clash with the actual request timeout.
                                 const idleTimeoutHandle = setTimeout(() => {
-                                    this.logger.trace({
-                                        message: `Removing socket ${socketId} after ${this.idleSocketTTL} ms of idle`,
-                                    });
+                                    if (log_level <= client_common_1.ClickHouseLogLevel.TRACE) {
+                                        log_writer.trace({
+                                            message: `${op}: removing idle socket`,
+                                            args: {
+                                                operation: op,
+                                                connection_id: this.connectionId,
+                                                query_id,
+                                                request_id,
+                                                socket_id,
+                                                idle_socket_ttl_ms: this.idleSocketTTL,
+                                            },
+                                        });
+                                    }
                                     this.knownSockets.delete(socket);
                                     socket.destroy();
                                 }, this.idleSocketTTL).unref();
-                                this.knownSockets.set(socket, {
-                                    id: socketId,
-                                    idle_timeout_handle: idleTimeoutHandle,
-                                });
+                                newSocketInfo.idle_timeout_handle = idleTimeoutHandle;
                             });
-                            const cleanup = () => {
+                            const cleanup = (eventName) => () => {
                                 const maybeSocketInfo = this.knownSockets.get(socket);
                                 // clean up a possibly dangling idle timeout handle (preventing leaks)
                                 if (maybeSocketInfo?.idle_timeout_handle) {
                                     clearTimeout(maybeSocketInfo.idle_timeout_handle);
                                 }
-                                this.logger.trace({
-                                    message: `Socket ${socketId} was closed or ended, 'free' listener removed`,
-                                });
-                                if (responseStream && !responseStream.readableEnded) {
-                                    this.logger.warn({
-                                        message: `${op}: socket was closed or ended before the response was fully read. ` +
-                                            'This can potentially result in an uncaught ECONNRESET error! ' +
-                                            'Consider fully consuming, draining, or destroying the response stream.',
+                                if (log_level <= client_common_1.ClickHouseLogLevel.TRACE) {
+                                    log_writer.trace({
+                                        message: `${op}: received '${eventName}' event, 'free' listener removed`,
                                         args: {
-                                            query: params.query,
-                                            query_id: params.url.searchParams.get('query_id') ?? 'unknown',
+                                            operation: op,
+                                            connection_id: this.connectionId,
+                                            query_id,
+                                            request_id,
+                                            socket_id,
+                                            event: eventName,
                                         },
                                     });
                                 }
+                                if (log_level <= client_common_1.ClickHouseLogLevel.WARN) {
+                                    if (responseStream && !responseStream.readableEnded) {
+                                        log_writer.warn({
+                                            message: `${op}: socket was closed or ended before the response was fully read. ` +
+                                                'This can potentially result in an uncaught ECONNRESET error! ' +
+                                                'Consider fully consuming, draining, or destroying the response stream.',
+                                            args: {
+                                                operation: op,
+                                                connection_id: this.connectionId,
+                                                query_id,
+                                                request_id,
+                                                socket_id,
+                                                event: eventName,
+                                                query: this.params.unsafeLogUnredactedQueries
+                                                    ? params.query
+                                                    : undefined,
+                                            },
+                                        });
+                                    }
+                                }
                             };
-                            socket.once('end', cleanup);
-                            socket.once('close', cleanup);
+                            socket.once('end', cleanup('end'));
+                            socket.once('close', cleanup('close'));
                         }
                         else {
                             clearTimeout(socketInfo.idle_timeout_handle);
-                            this.logger.trace({
-                                message: `Reusing socket ${socketInfo.id}`,
-                            });
-                            this.knownSockets.set(socket, {
-                                ...socketInfo,
-                                idle_timeout_handle: undefined,
-                            });
+                            socketInfo.idle_timeout_handle = undefined;
+                            if (log_level <= client_common_1.ClickHouseLogLevel.TRACE) {
+                                log_writer.trace({
+                                    message: `${op}: reusing socket`,
+                                    args: {
+                                        operation: op,
+                                        connection_id: this.connectionId,
+                                        query_id,
+                                        request_id,
+                                        socket_id: socketInfo.id,
+                                        usage_count: socketInfo.usage_count,
+                                    },
+                                });
+                            }
+                            socketInfo.usage_count++;
                         }
                     }
                 }
                 catch (e) {
-                    logger.error({
-                        message: 'An error occurred while housekeeping the idle sockets',
-                        err: e,
-                    });
+                    if (log_level <= client_common_1.ClickHouseLogLevel.ERROR) {
+                        log_writer.error({
+                            message: `${op}: an error occurred while housekeeping the idle sockets`,
+                            err: e,
+                            args: {
+                                operation: op,
+                                connection_id: this.connectionId,
+                                query_id,
+                                request_id,
+                            },
+                        });
+                    }
                 }
                 // Socket is "prepared" with idle handlers, continue with our request
                 pipeStream();
                 // This is for request timeout only. Surprisingly, it is not always enough to set in the HTTP request.
                 // The socket won't be destroyed, and it will be returned to the pool.
+                if (log_level <= client_common_1.ClickHouseLogLevel.TRACE) {
+                    const socketInfo = this.knownSockets.get(socket);
+                    if (socketInfo) {
+                        log_writer.trace({
+                            message: `${op}: setting up request timeout`,
+                            args: {
+                                operation: op,
+                                connection_id: this.connectionId,
+                                query_id,
+                                request_id,
+                                socket_id: socketInfo.id,
+                                timeout_ms: requestTimeout,
+                            },
+                        });
+                    }
+                    else {
+                        log_writer.trace({
+                            message: `${op}: setting up request timeout on a socket`,
+                            args: {
+                                operation: op,
+                                connection_id: this.connectionId,
+                                query_id,
+                                request_id,
+                                timeout_ms: requestTimeout,
+                            },
+                        });
+                    }
+                }
                 socket.setTimeout(this.params.request_timeout, onTimeout);
             };
-            function onTimeout() {
-                const err = (0, client_common_1.enhanceStackTrace)(new Error('Timeout error.'), currentStackTrace);
+            const onTimeout = () => {
                 removeRequestListeners();
+                if (log_level <= client_common_1.ClickHouseLogLevel.TRACE) {
+                    const socket = request.socket;
+                    const maybeSocketInfo = socket
+                        ? this.knownSockets.get(socket)
+                        : undefined;
+                    const socketState = request.socket
+                        ? {
+                            connecting: request.socket.connecting,
+                            pending: request.socket.pending,
+                            destroyed: request.socket.destroyed,
+                            readyState: request.socket.readyState,
+                        }
+                        : undefined;
+                    const responseStreamState = responseStream
+                        ? {
+                            readable: responseStream.readable,
+                            readableEnded: responseStream.readableEnded,
+                            readableLength: responseStream.readableLength,
+                        }
+                        : undefined;
+                    log_writer.trace({
+                        message: `${op}: timeout occurred`,
+                        args: {
+                            operation: op,
+                            connection_id: this.connectionId,
+                            query_id,
+                            request_id,
+                            socket_id: maybeSocketInfo?.id,
+                            timeout_ms: requestTimeout,
+                            socket_state: socketState,
+                            response_stream_state: responseStreamState,
+                            has_response_stream: responseStream !== undefined,
+                        },
+                    });
+                }
+                const err = (0, client_common_1.enhanceStackTrace)(new Error('Timeout error.'), currentStackTrace);
                 try {
                     request.destroy();
                 }
                 catch (e) {
-                    logger.error({
-                        message: 'An error occurred while destroying the request',
-                        err: e,
-                    });
+                    if (log_level <= client_common_1.ClickHouseLogLevel.ERROR) {
+                        log_writer.error({
+                            message: `${op}: An error occurred while destroying the request`,
+                            err: e,
+                            args: {
+                                operation: op,
+                                connection_id: this.connectionId,
+                                query_id,
+                                request_id,
+                            },
+                        });
+                    }
                 }
                 reject(err);
-            }
+            };
             function removeRequestListeners() {
                 if (request.socket !== null) {
                     request.socket.setTimeout(0); // reset previously set timeout
@@ -639,10 +884,18 @@ class NodeBaseConnection {
                     return request.end();
                 }
                 catch (e) {
-                    this.logger.error({
-                        message: 'An error occurred while ending the request without body',
-                        err: e,
-                    });
+                    if (log_level <= client_common_1.ClickHouseLogLevel.ERROR) {
+                        log_writer.error({
+                            message: `${op}: an error occurred while ending the request without body`,
+                            err: e,
+                            args: {
+                                operation: op,
+                                connection_id: this.connectionId,
+                                query_id,
+                                request_id,
+                            },
+                        });
+                    }
                 }
             }
         });