diff --git a/.gitignore b/.gitignore
index 24018fa..b1870ec 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,5 +3,4 @@ coverage
 .idea
 *.iml
 .DS_Store
-certs
 dist
\ No newline at end of file
diff --git a/package.json b/package.json
index 4c10ee7..3b6b129 100644
--- a/package.json
+++ b/package.json
@@ -7,6 +7,7 @@
     "build": "bunchee",
     "eslint": "eslint src/**",
     "typecheck": "tsc --noEmit",
+    "format": "prettier --write '{src,test}/**/*.{ts,js,json}'",
     "docs": "pnpm run build && jsdoc ./dist/cjs/index.js README.md -d docs",
     "preview:docs": "serve docs"
   },
diff --git a/src/buffer/index.ts b/src/buffer/index.ts
new file mode 100644
index 0000000..425ac8a
--- /dev/null
+++ b/src/buffer/index.ts
@@ -0,0 +1,436 @@
+// @ts-check
+import { Buffer } from "node:buffer";
+
+import { log, Logger } from "../logging";
+import { validateColumnName, validateTableName } from "../validation";
+import { SenderOptions } from "../options";
+import {
+  isInteger,
+  timestampToMicros,
+  timestampToNanos,
+  TimestampUnit,
+} from "../utils";
+
+const DEFAULT_MAX_NAME_LENGTH = 127;
+
+const DEFAULT_BUFFER_SIZE = 65536; //  64 KB
+const DEFAULT_MAX_BUFFER_SIZE = 104857600; // 100 MB
+
+/**
+ * Buffer used by the Sender.
+ */
+class SenderBuffer {
+  private bufferSize: number;
+  private readonly maxBufferSize: number;
+  private buffer: Buffer<ArrayBuffer>;
+  private position: number;
+  private endOfLastRow: number;
+
+  private hasTable: boolean;
+  private hasSymbols: boolean;
+  private hasColumns: boolean;
+
+  private readonly maxNameLength: number;
+
+  private readonly log: Logger;
+
+  /**
+   * Creates an instance of SenderBuffer.
+   *
+   * @param {SenderOptions} options - Sender configuration object. <br>
+   * See SenderOptions documentation for detailed description of configuration options. <br>
+   */
+  constructor(options: SenderOptions) {
+    this.log = options && typeof options.log === "function" ? options.log : log;
+    SenderOptions.resolveDeprecated(options, this.log);
+
+    this.maxNameLength =
+      options && isInteger(options.max_name_len, 1)
+        ? options.max_name_len
+        : DEFAULT_MAX_NAME_LENGTH;
+
+    this.maxBufferSize =
+      options && isInteger(options.max_buf_size, 1)
+        ? options.max_buf_size
+        : DEFAULT_MAX_BUFFER_SIZE;
+    this.resize(
+      options && isInteger(options.init_buf_size, 1)
+        ? options.init_buf_size
+        : DEFAULT_BUFFER_SIZE,
+    );
+
+    this.reset();
+  }
+
+  /**
+   * Extends the size of the buffer. <br>
+   * Can be used to increase the size of buffer if overflown.
+   * The buffer's content is copied into the new buffer.
+   *
+   * @param {number} bufferSize - New size of the buffer used by the sender, provided in bytes.
+   */
+  private resize(bufferSize: number) {
+    if (bufferSize > this.maxBufferSize) {
+      throw new Error(
+        `Max buffer size is ${this.maxBufferSize} bytes, requested buffer size: ${bufferSize}`,
+      );
+    }
+    this.bufferSize = bufferSize;
+    // Allocating an extra byte because Buffer.write() does not fail if the length of the data to be written is
+    // longer than the size of the buffer. It simply just writes whatever it can, and returns.
+    // If we can write into the extra byte, that indicates buffer overflow.
+    // See the check in the write() function.
+    const newBuffer = Buffer.alloc(this.bufferSize + 1, 0, "utf8");
+    if (this.buffer) {
+      this.buffer.copy(newBuffer);
+    }
+    this.buffer = newBuffer;
+  }
+
+  /**
+   * Resets the buffer, data added to the buffer will be lost. <br>
+   * In other words it clears the buffer and sets the writing position to the beginning of the buffer.
+   *
+   * @return {Sender} Returns with a reference to this sender.
+   */
+  reset(): SenderBuffer {
+    this.position = 0;
+    this.startNewRow();
+    return this;
+  }
+
+  private startNewRow() {
+    this.endOfLastRow = this.position;
+    this.hasTable = false;
+    this.hasSymbols = false;
+    this.hasColumns = false;
+  }
+
+  /**
+   * @ignore
+   * @return {Buffer} Returns a cropped buffer, or null if there is nothing to send.
+   * The returned buffer is backed by the sender's buffer.
+   * Used only in tests.
+   */
+  toBufferView(pos = this.endOfLastRow): Buffer {
+    return pos > 0 ? this.buffer.subarray(0, pos) : null;
+  }
+
+  /**
+   * @ignore
+   * @return {Buffer|null} Returns a cropped buffer ready to send to the server, or null if there is nothing to send.
+   * The returned buffer is a copy of the sender's buffer.
+   * It also compacts the Sender's buffer.
+   */
+  toBufferNew(pos = this.endOfLastRow): Buffer | null {
+    if (pos > 0) {
+      const data = Buffer.allocUnsafe(pos);
+      this.buffer.copy(data, 0, 0, pos);
+      this.compact();
+      return data;
+    }
+    return null;
+  }
+
+  /**
+   * Write the table name into the buffer of the sender.
+   *
+   * @param {string} table - Table name.
+   * @return {Sender} Returns with a reference to this sender.
+   */
+  table(table: string): SenderBuffer {
+    if (typeof table !== "string") {
+      throw new Error(`Table name must be a string, received ${typeof table}`);
+    }
+    if (this.hasTable) {
+      throw new Error("Table name has already been set");
+    }
+    validateTableName(table, this.maxNameLength);
+    this.checkCapacity([table], table.length);
+    this.writeEscaped(table);
+    this.hasTable = true;
+    return this;
+  }
+
+  /**
+   * Write a symbol name and value into the buffer of the sender.
+   *
+   * @param {string} name - Symbol name.
+   * @param {unknown} value - Symbol value, toString() is called to extract the actual symbol value from the parameter.
+   * @return {Sender} Returns with a reference to this sender.
+   */
+  symbol(name: string, value: unknown): SenderBuffer {
+    if (typeof name !== "string") {
+      throw new Error(`Symbol name must be a string, received ${typeof name}`);
+    }
+    if (!this.hasTable || this.hasColumns) {
+      throw new Error(
+        "Symbol can be added only after table name is set and before any column added",
+      );
+    }
+    const valueStr = value.toString();
+    this.checkCapacity([name, valueStr], 2 + name.length + valueStr.length);
+    this.write(",");
+    validateColumnName(name, this.maxNameLength);
+    this.writeEscaped(name);
+    this.write("=");
+    this.writeEscaped(valueStr);
+    this.hasSymbols = true;
+    return this;
+  }
+
+  /**
+   * Write a string column with its value into the buffer of the sender.
+   *
+   * @param {string} name - Column name.
+   * @param {string} value - Column value, accepts only string values.
+   * @return {Sender} Returns with a reference to this sender.
+   */
+  stringColumn(name: string, value: string): SenderBuffer {
+    this.writeColumn(
+      name,
+      value,
+      () => {
+        this.checkCapacity([value], 2 + value.length);
+        this.write('"');
+        this.writeEscaped(value, true);
+        this.write('"');
+      },
+      "string",
+    );
+    return this;
+  }
+
+  /**
+   * Write a boolean column with its value into the buffer of the sender.
+   *
+   * @param {string} name - Column name.
+   * @param {boolean} value - Column value, accepts only boolean values.
+   * @return {Sender} Returns with a reference to this sender.
+   */
+  booleanColumn(name: string, value: boolean): SenderBuffer {
+    this.writeColumn(
+      name,
+      value,
+      () => {
+        this.checkCapacity([], 1);
+        this.write(value ? "t" : "f");
+      },
+      "boolean",
+    );
+    return this;
+  }
+
+  /**
+   * Write a float column with its value into the buffer of the sender.
+   *
+   * @param {string} name - Column name.
+   * @param {number} value - Column value, accepts only number values.
+   * @return {Sender} Returns with a reference to this sender.
+   */
+  floatColumn(name: string, value: number): SenderBuffer {
+    this.writeColumn(
+      name,
+      value,
+      () => {
+        const valueStr = value.toString();
+        this.checkCapacity([valueStr]);
+        this.write(valueStr);
+      },
+      "number",
+    );
+    return this;
+  }
+
+  /**
+   * Write an integer column with its value into the buffer of the sender.
+   *
+   * @param {string} name - Column name.
+   * @param {number} value - Column value, accepts only number values.
+   * @return {Sender} Returns with a reference to this sender.
+   */
+  intColumn(name: string, value: number): SenderBuffer {
+    if (!Number.isInteger(value)) {
+      throw new Error(`Value must be an integer, received ${value}`);
+    }
+    this.writeColumn(name, value, () => {
+      const valueStr = value.toString();
+      this.checkCapacity([valueStr], 1);
+      this.write(valueStr);
+      this.write("i");
+    });
+    return this;
+  }
+
+  /**
+   * Write a timestamp column with its value into the buffer of the sender.
+   *
+   * @param {string} name - Column name.
+   * @param {number | bigint} value - Epoch timestamp, accepts numbers or BigInts.
+   * @param {string} [unit=us] - Timestamp unit. Supported values: 'ns' - nanoseconds, 'us' - microseconds, 'ms' - milliseconds. Defaults to 'us'.
+   * @return {Sender} Returns with a reference to this sender.
+   */
+  timestampColumn(
+    name: string,
+    value: number | bigint,
+    unit: TimestampUnit = "us",
+  ): SenderBuffer {
+    if (typeof value !== "bigint" && !Number.isInteger(value)) {
+      throw new Error(`Value must be an integer or BigInt, received ${value}`);
+    }
+    this.writeColumn(name, value, () => {
+      const valueMicros = timestampToMicros(BigInt(value), unit);
+      const valueStr = valueMicros.toString();
+      this.checkCapacity([valueStr], 1);
+      this.write(valueStr);
+      this.write("t");
+    });
+    return this;
+  }
+
+  /**
+   * Closing the row after writing the designated timestamp into the buffer of the sender.
+   *
+   * @param {number | bigint} timestamp - Designated epoch timestamp, accepts numbers or BigInts.
+   * @param {string} [unit=us] - Timestamp unit. Supported values: 'ns' - nanoseconds, 'us' - microseconds, 'ms' - milliseconds. Defaults to 'us'.
+   */
+  at(timestamp: number | bigint, unit: TimestampUnit = "us") {
+    if (!this.hasSymbols && !this.hasColumns) {
+      throw new Error(
+        "The row must have a symbol or column set before it is closed",
+      );
+    }
+    if (typeof timestamp !== "bigint" && !Number.isInteger(timestamp)) {
+      throw new Error(
+        `Designated timestamp must be an integer or BigInt, received ${timestamp}`,
+      );
+    }
+    const timestampNanos = timestampToNanos(BigInt(timestamp), unit);
+    const timestampStr = timestampNanos.toString();
+    this.checkCapacity([timestampStr], 2);
+    this.write(" ");
+    this.write(timestampStr);
+    this.write("\n");
+    this.startNewRow();
+  }
+
+  /**
+   * Closing the row without writing designated timestamp into the buffer of the sender. <br>
+   * Designated timestamp will be populated by the server on this record.
+   */
+  atNow() {
+    if (!this.hasSymbols && !this.hasColumns) {
+      throw new Error(
+        "The row must have a symbol or column set before it is closed",
+      );
+    }
+    this.checkCapacity([], 1);
+    this.write("\n");
+    this.startNewRow();
+  }
+
+  /**
+   * Returns the current position of the buffer.
+   * New data will be written into the buffer starting from this position.
+   */
+  currentPosition() {
+    return this.position;
+  }
+
+  private checkCapacity(data: string[], base = 0) {
+    let length = base;
+    for (const str of data) {
+      length += Buffer.byteLength(str, "utf8");
+    }
+    if (this.position + length > this.bufferSize) {
+      let newSize = this.bufferSize;
+      do {
+        newSize += this.bufferSize;
+      } while (this.position + length > newSize);
+      this.resize(newSize);
+    }
+  }
+
+  private compact() {
+    if (this.endOfLastRow > 0) {
+      this.buffer.copy(this.buffer, 0, this.endOfLastRow, this.position);
+      this.position = this.position - this.endOfLastRow;
+      this.endOfLastRow = 0;
+    }
+  }
+
+  private writeColumn(
+    name: string,
+    value: unknown,
+    writeValue: () => void,
+    valueType?: string,
+  ) {
+    if (typeof name !== "string") {
+      throw new Error(`Column name must be a string, received ${typeof name}`);
+    }
+    if (valueType && typeof value !== valueType) {
+      throw new Error(
+        `Column value must be of type ${valueType}, received ${typeof value}`,
+      );
+    }
+    if (!this.hasTable) {
+      throw new Error("Column can be set only after table name is set");
+    }
+    this.checkCapacity([name], 2 + name.length);
+    this.write(this.hasColumns ? "," : " ");
+    validateColumnName(name, this.maxNameLength);
+    this.writeEscaped(name);
+    this.write("=");
+    writeValue();
+    this.hasColumns = true;
+  }
+
+  private write(data: string) {
+    this.position += this.buffer.write(data, this.position);
+    if (this.position > this.bufferSize) {
+      // should never happen, if checkCapacity() is correctly used
+      throw new Error(
+        `Buffer overflow [position=${this.position}, bufferSize=${this.bufferSize}]`,
+      );
+    }
+  }
+
+  private writeEscaped(data: string, quoted = false) {
+    for (const ch of data) {
+      if (ch > "\\") {
+        this.write(ch);
+        continue;
+      }
+
+      switch (ch) {
+        case " ":
+        case ",":
+        case "=":
+          if (!quoted) {
+            this.write("\\");
+          }
+          this.write(ch);
+          break;
+        case "\n":
+        case "\r":
+          this.write("\\");
+          this.write(ch);
+          break;
+        case '"':
+          if (quoted) {
+            this.write("\\");
+          }
+          this.write(ch);
+          break;
+        case "\\":
+          this.write("\\\\");
+          break;
+        default:
+          this.write(ch);
+          break;
+      }
+    }
+  }
+}
+
+export { SenderBuffer, DEFAULT_BUFFER_SIZE, DEFAULT_MAX_BUFFER_SIZE };
diff --git a/src/logging.ts b/src/logging.ts
index 58b4ddf..751629e 100644
--- a/src/logging.ts
+++ b/src/logging.ts
@@ -7,15 +7,23 @@ const LOG_LEVELS = {
 
 const DEFAULT_CRITICALITY = LOG_LEVELS.info.criticality;
 
+type Logger = (
+  level: "error" | "warn" | "info" | "debug",
+  message: string | Error,
+) => void;
+
 /**
  * Simple logger to write log messages to the console. <br>
  * Supported logging levels are `error`, `warn`, `info` and `debug`. <br>
  * Throws an error if logging level is invalid.
  *
  * @param {'error'|'warn'|'info'|'debug'} level - The log level of the message.
- * @param {string} message - The log message.
+ * @param {string | Error} message - The log message.
  */
-function log(level: "error" | "warn" | "info" | "debug", message: string) {
+function log(
+  level: "error" | "warn" | "info" | "debug",
+  message: string | Error,
+) {
   const logLevel = LOG_LEVELS[level];
   if (!logLevel) {
     throw new Error(`Invalid log level: '${level}'`);
@@ -25,4 +33,4 @@ function log(level: "error" | "warn" | "info" | "debug", message: string) {
   }
 }
 
-export { log };
+export { log, Logger };
diff --git a/src/options.ts b/src/options.ts
index 9b32645..35e21fa 100644
--- a/src/options.ts
+++ b/src/options.ts
@@ -1,5 +1,9 @@
 import { PathOrFileDescriptor } from "fs";
 import { Agent } from "undici";
+import http from "http";
+import https from "https";
+
+import { Logger } from "./logging";
 
 const HTTP_PORT = 9000;
 const TCP_PORT = 9009;
@@ -13,6 +17,20 @@ const ON = "on";
 const OFF = "off";
 const UNSAFE_OFF = "unsafe_off";
 
+type ExtraOptions = {
+  log?: Logger;
+  agent?: Agent | http.Agent | https.Agent;
+};
+
+type DeprecatedOptions = {
+  /** @deprecated */
+  copy_buffer?: boolean;
+  /** @deprecated */
+  copyBuffer?: boolean;
+  /** @deprecated */
+  bufferSize?: number;
+};
+
 /** @classdesc
  * <a href="Sender.html">Sender</a> configuration options. <br>
  * <br>
@@ -102,6 +120,9 @@ const UNSAFE_OFF = "unsafe_off";
  * <br>
  * Other options
  * <ul>
+ * <li> stdlib_http: <i>enum, accepted values: on, off</i> - With HTTP protocol the Undici library is used by default. By setting this option
+ * to <i>on</i> the client switches to node's core http and https modules.
+ * </li>
  * <li> max_name_len: <i>integer</i> - The maximum length of a table or column name, the Sender defaults this parameter to 127. <br>
  * Recommended to use the same setting as the server, which also uses 127 by default.
  * </li>
@@ -139,10 +160,10 @@ class SenderOptions {
 
   max_name_len?: number;
 
-  log?:
-    | ((level: "error" | "warn" | "info" | "debug", message: string) => void)
-    | null;
-  agent?: Agent;
+  log?: Logger;
+  agent?: Agent | http.Agent | https.Agent;
+
+  stdlib_http?: boolean;
 
   auth?: {
     username?: string;
@@ -162,7 +183,7 @@ class SenderOptions {
    * - 'agent' is a custom http/https agent used by the <a href="Sender.html">Sender</a> when http/https transport is used. <br>
    * A <i>http.Agent</i> or <i>https.Agent</i> object is expected.
    */
-  constructor(configurationString: string, extraOptions = undefined) {
+  constructor(configurationString: string, extraOptions?: ExtraOptions) {
     parseConfigurationString(this, configurationString);
 
     if (extraOptions) {
@@ -171,13 +192,52 @@ class SenderOptions {
       }
       this.log = extraOptions.log;
 
-      if (extraOptions.agent && !(extraOptions.agent instanceof Agent)) {
-        throw new Error("Invalid http/https agent");
+      if (
+        extraOptions.agent &&
+        !(extraOptions.agent instanceof Agent) &&
+        !(extraOptions.agent instanceof http.Agent) &&
+        // @ts-expect-error - Not clear what the problem is, the two lines above have no issues
+        !(extraOptions.agent instanceof https.Agent)
+      ) {
+        throw new Error("Invalid HTTP agent");
       }
       this.agent = extraOptions.agent;
     }
   }
 
+  static resolveDeprecated(
+    options: SenderOptions & DeprecatedOptions,
+    log: Logger,
+  ) {
+    if (!options) {
+      return;
+    }
+
+    // deal with deprecated options
+    if (options.copy_buffer !== undefined) {
+      log(
+        "warn",
+        `Option 'copy_buffer' is not supported anymore, please, remove it`,
+      );
+      options.copy_buffer = undefined;
+    }
+    if (options.copyBuffer !== undefined) {
+      log(
+        "warn",
+        `Option 'copyBuffer' is not supported anymore, please, remove it`,
+      );
+      options.copyBuffer = undefined;
+    }
+    if (options.bufferSize !== undefined) {
+      log(
+        "warn",
+        `Option 'bufferSize' is not supported anymore, please, replace it with 'init_buf_size'`,
+      );
+      options.init_buf_size = options.bufferSize;
+      options.bufferSize = undefined;
+    }
+  }
+
   /**
    * Creates a Sender options object by parsing the provided configuration string.
    *
@@ -192,14 +252,8 @@ class SenderOptions {
    */
   static fromConfig(
     configurationString: string,
-    extraOptions: {
-      log?: (
-        level: "error" | "warn" | "info" | "debug",
-        message: string,
-      ) => void;
-      agent?: Agent;
-    } = undefined,
-  ) {
+    extraOptions?: ExtraOptions,
+  ): SenderOptions {
     return new SenderOptions(configurationString, extraOptions);
   }
 
@@ -214,7 +268,7 @@ class SenderOptions {
    *
    * @return {SenderOptions} A Sender configuration object initialized from the <b>QDB_CLIENT_CONF</b> environment variable.
    */
-  static fromEnv(extraOptions = undefined) {
+  static fromEnv(extraOptions?: ExtraOptions): SenderOptions {
     return SenderOptions.fromConfig(process.env.QDB_CLIENT_CONF, extraOptions);
   }
 }
@@ -235,6 +289,7 @@ function parseConfigurationString(
   parseTlsOptions(options);
   parseRequestTimeoutOptions(options);
   parseMaxNameLength(options);
+  parseStdlibTransport(options);
 }
 
 function parseSettings(
@@ -296,6 +351,7 @@ const ValidConfigKeys = [
   "init_buf_size",
   "max_buf_size",
   "max_name_len",
+  "stdlib_http",
   "tls_verify",
   "tls_ca",
   "tls_roots",
@@ -322,10 +378,7 @@ function validateConfigValue(key: string, value: string) {
   }
 }
 
-function parseProtocol(
-  options: SenderOptions,
-  configString: string | string[],
-) {
+function parseProtocol(options: SenderOptions, configString: string) {
   const index = configString.indexOf("::");
   if (index < 0) {
     throw new Error(
@@ -407,7 +460,7 @@ function parseTlsOptions(options: SenderOptions) {
   if (options.tls_roots || options.tls_roots_password) {
     throw new Error(
       "'tls_roots' and 'tls_roots_password' options are not supported, please, " +
-      "use the 'tls_ca' option or the NODE_EXTRA_CA_CERTS environment variable instead",
+        "use the 'tls_ca' option or the NODE_EXTRA_CA_CERTS environment variable instead",
     );
   }
 }
@@ -422,6 +475,10 @@ function parseMaxNameLength(options: SenderOptions) {
   parseInteger(options, "max_name_len", "max name length", 1);
 }
 
+function parseStdlibTransport(options: SenderOptions) {
+  parseBoolean(options, "stdlib_http", "stdlib http");
+}
+
 function parseBoolean(
   options: SenderOptions,
   property: string,
@@ -466,4 +523,4 @@ function parseInteger(
   }
 }
 
-export { SenderOptions, HTTP, HTTPS, TCP, TCPS };
+export { SenderOptions, ExtraOptions, HTTP, HTTPS, TCP, TCPS };
diff --git a/src/sender.ts b/src/sender.ts
index 4cc6cb9..5c88de2 100644
--- a/src/sender.ts
+++ b/src/sender.ts
@@ -1,61 +1,12 @@
 // @ts-check
-import { readFileSync } from "node:fs";
-import { Buffer } from "node:buffer";
-import net from "node:net";
-import tls from "node:tls";
-import crypto from "node:crypto";
-import { Agent, RetryAgent } from "undici";
+import { log, Logger } from "./logging";
+import { SenderOptions, ExtraOptions } from "./options";
+import { SenderTransport, createTransport } from "./transport";
+import { isBoolean, isInteger, TimestampUnit } from "./utils";
+import { SenderBuffer } from "./buffer";
 
-import { log } from "./logging";
-import { validateColumnName, validateTableName } from "./validation";
-import { SenderOptions, HTTP, HTTPS, TCP, TCPS } from "./options";
-
-const HTTP_NO_CONTENT = 204; // success
-
-const DEFAULT_HTTP_AUTO_FLUSH_ROWS = 75000;
-const DEFAULT_TCP_AUTO_FLUSH_ROWS = 600;
 const DEFAULT_AUTO_FLUSH_INTERVAL = 1000; // 1 sec
 
-const DEFAULT_MAX_NAME_LENGTH = 127;
-
-const DEFAULT_REQUEST_MIN_THROUGHPUT = 102400; // 100 KB/sec
-const DEFAULT_REQUEST_TIMEOUT = 10000; // 10 sec
-const DEFAULT_RETRY_TIMEOUT = 10000; // 10 sec
-
-const DEFAULT_BUFFER_SIZE = 65536; //  64 KB
-const DEFAULT_MAX_BUFFER_SIZE = 104857600; // 100 MB
-
-/** @type {Agent.Options} */
-const DEFAULT_HTTP_OPTIONS: Agent.Options = {
-  connect: {
-    keepAlive: true,
-  },
-  pipelining: 1,
-  keepAliveTimeout: 60000, // 1 minute
-};
-// an arbitrary public key, not used in authentication
-// only used to construct a valid JWK token which is accepted by the crypto API
-const PUBLIC_KEY = {
-  x: "aultdA0PjhD_cWViqKKyL5chm6H1n-BiZBo_48T-uqc",
-  y: "__ptaol41JWSpTTL525yVEfzmY8A6Vi_QrW1FjKcHMg",
-};
-
-/*
-We are retrying on the following response codes (copied from the Rust client):
-500:  Internal Server Error
-503:  Service Unavailable
-504:  Gateway Timeout
-
-// Unofficial extensions
-507:  Insufficient Storage
-509:  Bandwidth Limit Exceeded
-523:  Origin is Unreachable
-524:  A Timeout Occurred
-529:  Site is overloaded
-599:  Network Connect Timeout Error
-*/
-const RETRIABLE_STATUS_CODES = [500, 503, 504, 507, 509, 523, 524, 529, 599];
-
 /** @classdesc
  * The QuestDB client's API provides methods to connect to the database, ingest data, and close the connection.
  * The supported protocols are HTTP and TCP. HTTP is preferred as it provides feedback in the HTTP response. <br>
@@ -101,48 +52,17 @@ const RETRIABLE_STATUS_CODES = [500, 503, 504, 507, 509, 523, 524, 529, 599];
  * </p>
  */
 class Sender {
-  /** @private */ static DEFAULT_HTTP_AGENT;
-  /** @private */ static DEFAULT_HTTPS_AGENT;
-
-  /** @private */ http; // true if the protocol is HTTP/HTTPS, false if it is TCP/TCPS
-  /** @private */ secure; // true if the protocol is HTTPS or TCPS, false otherwise
-  /** @private */ host;
-  /** @private */ port;
-
-  /** @private */ socket;
+  private readonly transport: SenderTransport;
 
-  /** @private */ username;
-  /** @private */ password;
-  /** @private */ token;
+  private readonly buffer: SenderBuffer;
 
-  /** @private */ tlsVerify;
-  /** @private */ tlsCA;
+  private readonly autoFlush: boolean;
+  private readonly autoFlushRows: number;
+  private readonly autoFlushInterval: number;
+  private lastFlushTime: number;
+  private pendingRowCount: number;
 
-  /** @private */ bufferSize;
-  /** @private */ maxBufferSize;
-  /** @private */ buffer;
-  /** @private */ position;
-  /** @private */ endOfLastRow;
-
-  /** @private */ autoFlush;
-  /** @private */ autoFlushRows;
-  /** @private */ autoFlushInterval;
-  /** @private */ lastFlushTime;
-  /** @private */ pendingRowCount;
-
-  /** @private */ requestMinThroughput;
-  /** @private */ requestTimeout;
-  /** @private */ retryTimeout;
-
-  /** @private */ hasTable;
-  /** @private */ hasSymbols;
-  /** @private */ hasColumns;
-
-  /** @private */ maxNameLength;
-
-  /** @private */ log;
-  /** @private */ agent;
-  /** @private */ jwk;
+  private readonly log: Logger;
 
   /**
    * Creates an instance of Sender.
@@ -151,106 +71,19 @@ class Sender {
    * See SenderOptions documentation for detailed description of configuration options. <br>
    */
   constructor(options: SenderOptions) {
-    if (!options || !options.protocol) {
-      throw new Error("The 'protocol' option is mandatory");
-    }
-    this.log = typeof options.log === "function" ? options.log : log;
-    replaceDeprecatedOptions(options, this.log);
-
-    switch (options.protocol) {
-      case HTTP:
-        this.http = true;
-        this.secure = false;
-        this.agent =
-          options.agent instanceof Agent
-            ? options.agent
-            : Sender.getDefaultHttpAgent();
-        break;
-      case HTTPS:
-        this.http = true;
-        this.secure = true;
-        if (options.agent instanceof Agent) {
-          this.agent = options.agent;
-        } else {
-          // Create a new agent with instance-specific TLS options
-          this.agent = new Agent({
-            ...DEFAULT_HTTP_OPTIONS,
-            connect: {
-              ...DEFAULT_HTTP_OPTIONS.connect,
-              requestCert: isBoolean(options.tls_verify) ? options.tls_verify : true,
-              rejectUnauthorized: isBoolean(options.tls_verify) ? options.tls_verify : true,
-              ca: options.tls_ca ? readFileSync(options.tls_ca) : undefined,
-            },
-          });
-        }
-        break;
-      case TCP:
-        this.http = false;
-        this.secure = false;
-        break;
-      case TCPS:
-        this.http = false;
-        this.secure = true;
-        break;
-      default:
-        throw new Error(`Invalid protocol: '${options.protocol}'`);
-    }
+    this.transport = createTransport(options);
+    this.buffer = new SenderBuffer(options);
 
-    if (this.http) {
-      this.username = options.username;
-      this.password = options.password;
-      this.token = options.token;
-      if (!options.port) {
-        options.port = 9000;
-      }
-    } else {
-      if (!options.auth && !options.jwk) {
-        constructAuth(options);
-      }
-      this.jwk = constructJwk(options);
-      if (!options.port) {
-        options.port = 9009;
-      }
-    }
-
-    this.host = options.host;
-    this.port = options.port;
-
-    this.tlsVerify = isBoolean(options.tls_verify) ? options.tls_verify : true;
-    this.tlsCA = options.tls_ca ? readFileSync(options.tls_ca) : undefined;
+    this.log = typeof options.log === "function" ? options.log : log;
 
     this.autoFlush = isBoolean(options.auto_flush) ? options.auto_flush : true;
     this.autoFlushRows = isInteger(options.auto_flush_rows, 0)
       ? options.auto_flush_rows
-      : this.http
-        ? DEFAULT_HTTP_AUTO_FLUSH_ROWS
-        : DEFAULT_TCP_AUTO_FLUSH_ROWS;
+      : this.transport.getDefaultAutoFlushRows();
     this.autoFlushInterval = isInteger(options.auto_flush_interval, 0)
       ? options.auto_flush_interval
       : DEFAULT_AUTO_FLUSH_INTERVAL;
 
-    this.maxNameLength = isInteger(options.max_name_len, 1)
-      ? options.max_name_len
-      : DEFAULT_MAX_NAME_LENGTH;
-
-    this.requestMinThroughput = isInteger(options.request_min_throughput, 0)
-      ? options.request_min_throughput
-      : DEFAULT_REQUEST_MIN_THROUGHPUT;
-    this.requestTimeout = isInteger(options.request_timeout, 1)
-      ? options.request_timeout
-      : DEFAULT_REQUEST_TIMEOUT;
-    this.retryTimeout = isInteger(options.retry_timeout, 0)
-      ? options.retry_timeout
-      : DEFAULT_RETRY_TIMEOUT;
-
-    this.maxBufferSize = isInteger(options.max_buf_size, 1)
-      ? options.max_buf_size
-      : DEFAULT_MAX_BUFFER_SIZE;
-    this.resize(
-      isInteger(options.init_buf_size, 1)
-        ? options.init_buf_size
-        : DEFAULT_BUFFER_SIZE,
-    );
     this.reset();
   }
 
@@ -268,7 +101,7 @@ class Sender {
    */
   static fromConfig(
     configurationString: string,
-    extraOptions: object = undefined,
+    extraOptions?: ExtraOptions,
   ): Sender {
     return new Sender(
       SenderOptions.fromConfig(configurationString, extraOptions),
@@ -286,37 +119,12 @@ class Sender {
    *
    * @return {Sender} A Sender object initialized from the <b>QDB_CLIENT_CONF</b> environment variable.
    */
-  static fromEnv(extraOptions: object = undefined): Sender {
+  static fromEnv(extraOptions?: ExtraOptions): Sender {
     return new Sender(
       SenderOptions.fromConfig(process.env.QDB_CLIENT_CONF, extraOptions),
     );
   }
 
-  /**
-   * Extends the size of the sender's buffer. <br>
-   * Can be used to increase the size of buffer if overflown.
-   * The buffer's content is copied into the new buffer.
-   *
-   * @param {number} bufferSize - New size of the buffer used by the sender, provided in bytes.
-   */
-  resize(bufferSize: number) {
-    if (bufferSize > this.maxBufferSize) {
-      throw new Error(
-        `Max buffer size is ${this.maxBufferSize} bytes, requested buffer size: ${bufferSize}`,
-      );
-    }
-    this.bufferSize = bufferSize;
-    // Allocating an extra byte because Buffer.write() does not fail if the length of the data to be written is
-    // longer than the size of the buffer. It simply just writes whatever it can, and returns.
-    // If we can write into the extra byte, that indicates buffer overflow.
-    // See the check in our write() function.
-    const newBuffer = Buffer.alloc(this.bufferSize + 1, 0, "utf8");
-    if (this.buffer) {
-      this.buffer.copy(newBuffer);
-    }
-    this.buffer = newBuffer;
-  }
-
   /**
    * Resets the buffer, data added to the buffer will be lost. <br>
    * In other words it clears the buffer and sets the writing position to the beginning of the buffer.
@@ -324,112 +132,18 @@ class Sender {
    * @return {Sender} Returns with a reference to this sender.
    */
   reset(): Sender {
-    this.position = 0;
-    this.lastFlushTime = Date.now();
-    this.pendingRowCount = 0;
-    startNewRow(this);
+    this.buffer.reset();
+    this.resetAutoFlush();
     return this;
   }
 
   /**
    * Creates a TCP connection to the database.
    *
-   * @param {net.NetConnectOpts | tls.ConnectionOptions} connectOptions - Connection options, host and port are required.
-   *
    * @return {Promise<boolean>} Resolves to true if the client is connected.
    */
-  connect(
-    connectOptions: net.NetConnectOpts | tls.ConnectionOptions = undefined,
-  ): Promise<boolean> {
-    if (this.http) {
-      throw new Error(
-        "'connect()' should be called only if the sender connects via TCP",
-      );
-    }
-
-    if (!connectOptions) {
-      connectOptions = {
-        host: this.host,
-        port: this.port,
-        ca: this.tlsCA,
-      };
-    }
-    if (!(connectOptions as tls.ConnectionOptions).host) {
-      throw new Error("Hostname is not set");
-    }
-    if (!(connectOptions as tls.ConnectionOptions).port) {
-      throw new Error("Port is not set");
-    }
-
-    return new Promise((resolve, reject) => {
-      if (this.socket) {
-        throw new Error("Sender connected already");
-      }
-
-      let authenticated: boolean = false;
-      let data;
-
-      this.socket = !this.secure
-        ? net.connect(connectOptions as net.NetConnectOpts)
-        : tls.connect(connectOptions, () => {
-          if (authenticated) {
-            resolve(true);
-          }
-        });
-      this.socket.setKeepAlive(true);
-
-      this.socket
-        .on("data", async (raw) => {
-          data = !data ? raw : Buffer.concat([data, raw]);
-          if (!authenticated) {
-            authenticated = await authenticate(this, data);
-            if (authenticated) {
-              resolve(true);
-            }
-          } else {
-            this.log("warn", `Received unexpected data: ${data}`);
-          }
-        })
-        .on("ready", async () => {
-          this.log(
-            "info",
-            `Successfully connected to ${(connectOptions as tls.ConnectionOptions).host}:${(connectOptions as tls.ConnectionOptions).port}`,
-          );
-          if (this.jwk) {
-            this.log(
-              "info",
-              `Authenticating with ${(connectOptions as tls.ConnectionOptions).host}:${(connectOptions as tls.ConnectionOptions).port}`,
-            );
-            await this.socket.write(`${this.jwk.kid}\n`, (err: Error) => {
-              if (err) {
-                reject(err);
-              }
-            });
-          } else {
-            authenticated = true;
-            if (!this.secure || !this.tlsVerify) {
-              resolve(true);
-            }
-          }
-        })
-        .on("error", (err) => {
-          this.log("error", err);
-          if (err.code !== "SELF_SIGNED_CERT_IN_CHAIN" || this.tlsVerify) {
-            reject(err);
-          }
-        });
-    });
-  }
-
-  /**
-   * @ignore
-   * @return {Agent} Returns the default http agent.
-   */
-  static getDefaultHttpAgent(): Agent {
-    if (!Sender.DEFAULT_HTTP_AGENT) {
-      Sender.DEFAULT_HTTP_AGENT = new Agent(DEFAULT_HTTP_OPTIONS);
-    }
-    return Sender.DEFAULT_HTTP_AGENT;
+  connect(): Promise<boolean> {
+    return this.transport.connect();
   }
 
   /**
@@ -439,143 +153,33 @@ class Sender {
    * @return {Promise<boolean>} Resolves to true when there was data in the buffer to send, and it was sent successfully.
    */
   async flush(): Promise<boolean> {
-    const dataToSend = this.toBufferNew(this.endOfLastRow);
+    const dataToSend: Buffer = this.buffer.toBufferNew();
     if (!dataToSend) {
       return false; // Nothing to send
     }
 
-    try {
-      if (this.http) {
-        const { timeout: calculatedTimeoutMillis } = createRequestOptions(this, dataToSend);
-        const retryBegin = Date.now();
-        const headers: Record<string, string> = {};
-
-        const dispatcher = new RetryAgent(this.agent, {
-          maxRetries: Infinity,
-          minTimeout: 10,
-          maxTimeout: 1000,
-          timeoutFactor: 2,
-          retryAfter: true,
-          methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"],
-          statusCodes: RETRIABLE_STATUS_CODES,
-          errorCodes: [
-            "ECONNRESET",
-            "EAI_AGAIN",
-            "ECONNREFUSED",
-            "ETIMEDOUT",
-            "EPIPE",
-            "UND_ERR_CONNECT_TIMEOUT",
-            "UND_ERR_HEADERS_TIMEOUT",
-            "UND_ERR_BODY_TIMEOUT",
-          ],
-          retry: (err, context, callback) => {
-            const elapsed = Date.now() - retryBegin;
-            if (elapsed > this.retryTimeout) {
-              return callback(err);
-            }
-            return callback(null);
-          },
-        });
-
-        if (this.token) {
-          headers["Authorization"] = "Bearer " + this.token;
-        } else if (this.username && this.password) {
-          headers["Authorization"] =
-            "Basic " +
-            Buffer.from(this.username + ":" + this.password).toString("base64");
-        }
-
-        const { statusCode, body } = await dispatcher.request({
-          origin: `${this.secure ? "https" : "http"}://${this.host}:${this.port}`,
-          path: "/write?precision=n",
-          method: "POST",
-          headers,
-          body: dataToSend,
-          headersTimeout: this.requestTimeout,
-          bodyTimeout: calculatedTimeoutMillis,
-        });
+    this.log(
+      "debug",
+      `Flushing, number of flushed rows: ${this.pendingRowCount}`,
+    );
+    this.resetAutoFlush();
 
-        const responseBody = await body.arrayBuffer();
-        if (statusCode === HTTP_NO_CONTENT) {
-          if (responseBody.byteLength > 0) {
-            this.log(
-              "warn",
-              `Unexpected message from server: ${Buffer.from(responseBody).toString()}`,
-            );
-          }
-          return true;
-        } else {
-          throw new Error(
-            `HTTP request failed, statusCode=${statusCode}, error=${Buffer.from(responseBody).toString()}`,
-          );
-        }
-      } else { // TCP
-        if (!this.socket || this.socket.destroyed) {
-          throw new Error("Sender is not connected");
-        }
-        return new Promise((resolve, reject) => {
-          this.socket.write(dataToSend, (err: Error) => { // Use the copied dataToSend
-            if (err) {
-              reject(err);
-            } else {
-              resolve(true);
-            }
-          });
-        });
-      }
-    } catch (err) {
-      // Log the error and then throw a new, standardized error
-      if (this.http && err.code === "UND_ERR_HEADERS_TIMEOUT") {
-        this.log("error", `HTTP request timeout, no response from server in time. Original error: ${err.message}`);
-        throw new Error(`HTTP request timeout, statusCode=${err.statusCode}, error=${err.message}`);
-      } else if (this.http) {
-        this.log("error", `HTTP request failed, statusCode=${err.statusCode || 'unknown'}, error=${err.message}`);
-        throw new Error(`HTTP request failed, statusCode=${err.statusCode || 'unknown'}, error=${err.message}`);
-      } else { // TCP
-        this.log("error", `TCP send failed: ${err.message}`);
-        throw new Error(`TCP send failed, error=${err.message}`);
-      }
-    }
+    await this.transport.send(dataToSend);
   }
 
   /**
-   * Closes the TCP connection to the database. <br>
+   * Closes the connection to the database. <br>
    * Data sitting in the Sender's buffer will be lost unless flush() is called before close().
    */
   async close() {
-    if (this.socket) {
-      const address = this.socket.remoteAddress;
-      const port = this.socket.remotePort;
-      this.socket.destroy();
-      this.socket = null;
-      this.log("info", `Connection to ${address}:${port} is closed`);
-    }
-  }
-
-  /**
-   * @ignore
-   * @return {Buffer} Returns a cropped buffer, or null if there is nothing to send.
-   * The returned buffer is backed by the sender's buffer.
-   * Used only in tests.
-   */
-  toBufferView(pos = this.position): Buffer {
-    return pos > 0 ? this.buffer.subarray(0, pos) : null;
-  }
-
-  /**
-   * @ignore
-   * @return {Buffer|null} Returns a cropped buffer ready to send to the server, or null if there is nothing to send.
-   * The returned buffer is a copy of the sender's buffer.
-   * It also compacts the Sender's buffer.
-   */
-  toBufferNew(pos = this.position): Buffer | null {
+    const pos = this.buffer.currentPosition();
     if (pos > 0) {
-      const data = Buffer.allocUnsafe(pos);
-      this.buffer.copy(data, 0, 0, pos);
-      compact(this);
-      return data;
+      this.log(
+        "warn",
+        `Buffer contains data which has not been flushed before closing the sender, and it will be lost [position=${pos}]`,
+      );
     }
-    return null;
+    return this.transport.close();
   }
 
   /**
@@ -585,16 +189,7 @@ class Sender {
    * @return {Sender} Returns with a reference to this sender.
    */
   table(table: string): Sender {
-    if (typeof table !== "string") {
-      throw new Error(`Table name must be a string, received ${typeof table}`);
-    }
-    if (this.hasTable) {
-      throw new Error("Table name has already been set");
-    }
-    validateTableName(table, this.maxNameLength);
-    checkCapacity(this, [table]);
-    writeEscaped(this, table);
-    this.hasTable = true;
+    this.buffer.table(table);
     return this;
   }
 
@@ -602,26 +197,11 @@ class Sender {
    * Write a symbol name and value into the buffer of the sender.
    *
    * @param {string} name - Symbol name.
-   * @param {any} value - Symbol value, toString() will be called to extract the actual symbol value from the parameter.
+   * @param {unknown} value - Symbol value, toString() is called to extract the actual symbol value from the parameter.
    * @return {Sender} Returns with a reference to this sender.
    */
-  symbol<T = unknown>(name: string, value: T): Sender {
-    if (typeof name !== "string") {
-      throw new Error(`Symbol name must be a string, received ${typeof name}`);
-    }
-    if (!this.hasTable || this.hasColumns) {
-      throw new Error(
-        "Symbol can be added only after table name is set and before any column added",
-      );
-    }
-    const valueStr = value.toString();
-    checkCapacity(this, [name, valueStr], 2 + name.length + valueStr.length);
-    write(this, ",");
-    validateColumnName(name, this.maxNameLength);
-    writeEscaped(this, name);
-    write(this, "=");
-    writeEscaped(this, valueStr);
-    this.hasSymbols = true;
+  symbol(name: string, value: unknown): Sender {
+    this.buffer.symbol(name, value);
     return this;
   }
 
@@ -633,18 +213,7 @@ class Sender {
    * @return {Sender} Returns with a reference to this sender.
    */
   stringColumn(name: string, value: string): Sender {
-    writeColumn(
-      this,
-      name,
-      value,
-      () => {
-        checkCapacity(this, [value], 2 + value.length);
-        write(this, '"');
-        writeEscaped(this, value, true);
-        write(this, '"');
-      },
-      "string",
-    );
+    this.buffer.stringColumn(name, value);
     return this;
   }
 
@@ -656,16 +225,7 @@ class Sender {
    * @return {Sender} Returns with a reference to this sender.
    */
   booleanColumn(name: string, value: boolean): Sender {
-    writeColumn(
-      this,
-      name,
-      value,
-      () => {
-        checkCapacity(this, [], 1);
-        write(this, value ? "t" : "f");
-      },
-      "boolean",
-    );
+    this.buffer.booleanColumn(name, value);
     return this;
   }
 
@@ -677,17 +237,7 @@ class Sender {
    * @return {Sender} Returns with a reference to this sender.
    */
   floatColumn(name: string, value: number): Sender {
-    writeColumn(
-      this,
-      name,
-      value,
-      () => {
-        const valueStr = value.toString();
-        checkCapacity(this, [valueStr], valueStr.length);
-        write(this, valueStr);
-      },
-      "number",
-    );
+    this.buffer.floatColumn(name, value);
     return this;
   }
 
@@ -699,15 +249,7 @@ class Sender {
    * @return {Sender} Returns with a reference to this sender.
    */
   intColumn(name: string, value: number): Sender {
-    if (!Number.isInteger(value)) {
-      throw new Error(`Value must be an integer, received ${value}`);
-    }
-    writeColumn(this, name, value, () => {
-      const valueStr = value.toString();
-      checkCapacity(this, [valueStr], 1 + valueStr.length);
-      write(this, valueStr);
-      write(this, "i");
-    });
+    this.buffer.intColumn(name, value);
     return this;
   }
 
@@ -722,18 +264,9 @@ class Sender {
   timestampColumn(
     name: string,
     value: number | bigint,
-    unit: "ns" | "us" | "ms" = "us",
+    unit: TimestampUnit = "us",
   ): Sender {
-    if (typeof value !== "bigint" && !Number.isInteger(value)) {
-      throw new Error(`Value must be an integer or BigInt, received ${value}`);
-    }
-    writeColumn(this, name, value, () => {
-      const valueMicros = timestampToMicros(BigInt(value), unit);
-      const valueStr = valueMicros.toString();
-      checkCapacity(this, [valueStr], 1 + valueStr.length);
-      write(this, valueStr);
-      write(this, "t");
-    });
+    this.buffer.timestampColumn(name, value, unit);
     return this;
   }
 
@@ -743,26 +276,11 @@ class Sender {
    * @param {number | bigint} timestamp - Designated epoch timestamp, accepts numbers or BigInts.
    * @param {string} [unit=us] - Timestamp unit. Supported values: 'ns' - nanoseconds, 'us' - microseconds, 'ms' - milliseconds. Defaults to 'us'.
    */
-  async at(timestamp: number | bigint, unit: "ns" | "us" | "ms" = "us") {
-    if (!this.hasSymbols && !this.hasColumns) {
-      throw new Error(
-        "The row must have a symbol or column set before it is closed",
-      );
-    }
-    if (typeof timestamp !== "bigint" && !Number.isInteger(timestamp)) {
-      throw new Error(
-        `Designated timestamp must be an integer or BigInt, received ${timestamp}`,
-      );
-    }
-    const timestampNanos = timestampToNanos(BigInt(timestamp), unit);
-    const timestampStr = timestampNanos.toString();
-    checkCapacity(this, [], 2 + timestampStr.length);
-    write(this, " ");
-    write(this, timestampStr);
-    write(this, "\n");
+  async at(timestamp: number | bigint, unit: TimestampUnit = "us") {
+    this.buffer.at(timestamp, unit);
     this.pendingRowCount++;
-    startNewRow(this);
-    await autoFlush(this);
+    this.log("debug", `Pending row count: ${this.pendingRowCount}`);
+    await this.tryFlush();
   }
 
   /**
@@ -770,312 +288,29 @@ class Sender {
    * Designated timestamp will be populated by the server on this record.
    */
   async atNow() {
-    if (!this.hasSymbols && !this.hasColumns) {
-      throw new Error(
-        "The row must have a symbol or column set before it is closed",
-      );
-    }
-    checkCapacity(this, [], 1);
-    write(this, "\n");
+    this.buffer.atNow();
     this.pendingRowCount++;
-    startNewRow(this);
-    await autoFlush(this);
-  }
-}
-
-function isBoolean(value: unknown): value is boolean {
-  return typeof value === "boolean";
-}
-
-function isInteger(value: unknown, lowerBound: number): value is number {
-  return (
-    typeof value === "number" && Number.isInteger(value) && value >= lowerBound
-  );
-}
-
-async function authenticate(
-  sender: Sender,
-  challenge: Buffer,
-): Promise<boolean> {
-  // Check for trailing \n which ends the challenge
-  if (challenge.subarray(-1).readInt8() === 10) {
-    const keyObject = crypto.createPrivateKey({
-      key: sender.jwk,
-      format: "jwk",
-    });
-    const signature = crypto.sign(
-      "RSA-SHA256",
-      challenge.subarray(0, challenge.length - 1),
-      keyObject,
-    );
-
-    return new Promise((resolve, reject) => {
-      sender.socket.write(
-        `${Buffer.from(signature).toString("base64")}\n`,
-        (err: Error) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve(true);
-          }
-        },
-      );
-    });
-  }
-  return false;
-}
-
-function startNewRow(sender: Sender) {
-  sender.endOfLastRow = sender.position;
-  sender.hasTable = false;
-  sender.hasSymbols = false;
-  sender.hasColumns = false;
-}
-
-type InternalHttpOptions = {
-  hostname: string;
-  port: number;
-  agent: Agent;
-  protocol: string;
-  path: string;
-  method: string;
-  timeout: number;
-};
-function createRequestOptions(
-  sender: Sender,
-  data: Buffer,
-): InternalHttpOptions {
-  const timeoutMillis =
-    (data.length / sender.requestMinThroughput) * 1000 + sender.requestTimeout;
-  return {
-    hostname: sender.host,
-    port: sender.port,
-    agent: sender.agent,
-    protocol: sender.secure ? "https" : "http",
-    path: "/write?precision=n",
-    method: "POST",
-    timeout: timeoutMillis,
-  };
-}
-
-async function autoFlush(sender: Sender) {
-  if (
-    sender.autoFlush &&
-    sender.pendingRowCount > 0 &&
-    ((sender.autoFlushRows > 0 &&
-      sender.pendingRowCount >= sender.autoFlushRows) ||
-      (sender.autoFlushInterval > 0 &&
-        Date.now() - sender.lastFlushTime >= sender.autoFlushInterval))
-  ) {
-    await sender.flush();
-  }
-}
-
-function checkCapacity(sender: Sender, data: string[], base = 0) {
-  let length = base;
-  for (const str of data) {
-    length += Buffer.byteLength(str, "utf8");
-  }
-  if (sender.position + length > sender.bufferSize) {
-    let newSize = sender.bufferSize;
-    do {
-      newSize += sender.bufferSize;
-    } while (sender.position + length > newSize);
-    sender.resize(newSize);
-  }
-}
-
-function compact(sender: Sender) {
-  if (sender.endOfLastRow > 0) {
-    sender.buffer.copy(sender.buffer, 0, sender.endOfLastRow, sender.position);
-    sender.position = sender.position - sender.endOfLastRow;
-    sender.endOfLastRow = 0;
-
-    sender.lastFlushTime = Date.now();
-    sender.pendingRowCount = 0;
-  }
-}
-
-function writeColumn(
-  sender: Sender,
-  name: string,
-  value: unknown,
-  writeValue: () => void,
-  valueType?: string | null,
-) {
-  if (typeof name !== "string") {
-    throw new Error(`Column name must be a string, received ${typeof name}`);
-  }
-  if (valueType != null && typeof value !== valueType) {
-    throw new Error(
-      `Column value must be of type ${valueType}, received ${typeof value}`,
-    );
-  }
-  if (!sender.hasTable) {
-    throw new Error("Column can be set only after table name is set");
-  }
-  checkCapacity(sender, [name], 2 + name.length);
-  write(sender, sender.hasColumns ? "," : " ");
-  validateColumnName(name, sender.maxNameLength);
-  writeEscaped(sender, name);
-  write(sender, "=");
-  writeValue();
-  sender.hasColumns = true;
-}
-
-function write(sender: Sender, data: string) {
-  sender.position += sender.buffer.write(data, sender.position);
-  if (sender.position > sender.bufferSize) {
-    throw new Error(
-      `Buffer overflow [position=${sender.position}, bufferSize=${sender.bufferSize}]`,
-    );
-  }
-}
-
-function writeEscaped(sender: Sender, data: string, quoted = false) {
-  for (const ch of data) {
-    if (ch > "\\") {
-      write(sender, ch);
-      continue;
-    }
-
-    switch (ch) {
-      case " ":
-      case ",":
-      case "=":
-        if (!quoted) {
-          write(sender, "\\");
-        }
-        write(sender, ch);
-        break;
-      case "\n":
-      case "\r":
-        write(sender, "\\");
-        write(sender, ch);
-        break;
-      case '"':
-        if (quoted) {
-          write(sender, "\\");
-        }
-        write(sender, ch);
-        break;
-      case "\\":
-        write(sender, "\\\\");
-        break;
-      default:
-        write(sender, ch);
-        break;
-    }
-  }
-}
-
-function timestampToMicros(timestamp: bigint, unit: "ns" | "us" | "ms") {
-  switch (unit) {
-    case "ns":
-      return timestamp / 1000n;
-    case "us":
-      return timestamp;
-    case "ms":
-      return timestamp * 1000n;
-    default:
-      throw new Error("Unknown timestamp unit: " + unit);
-  }
-}
-
-function timestampToNanos(timestamp: bigint, unit: "ns" | "us" | "ms") {
-  switch (unit) {
-    case "ns":
-      return timestamp;
-    case "us":
-      return timestamp * 1000n;
-    case "ms":
-      return timestamp * 1000_000n;
-    default:
-      throw new Error("Unknown timestamp unit: " + unit);
-  }
-}
-
-type DeprecatedOptions = {
-  /** @deprecated */
-  copy_buffer?: boolean;
-  /** @deprecated */
-  copyBuffer?: boolean;
-  /** @deprecated */
-  bufferSize?: number;
-};
-function replaceDeprecatedOptions(
-    options: SenderOptions & DeprecatedOptions,
-    log: (level: "error" | "warn" | "info" | "debug", message: string) => void
-) {
-  // deal with deprecated options
-  if (options.copy_buffer !== undefined) {
-    log("warn", `Option 'copy_buffer' is not supported anymore, please, remove it`);
-  }
-  if (options.copyBuffer !== undefined) {
-    log("warn", `Option 'copyBuffer' is not supported anymore, please, remove it`);
-  }
-  if (options.bufferSize !== undefined) {
-    log("warn", `Option 'bufferSize' is not supported anymore, please, replace it with 'init_buf_size'`);
-    options.init_buf_size = options.bufferSize;
-    options.bufferSize = undefined;
-  }
-}
-
-function constructAuth(options: SenderOptions) {
-  if (!options.username && !options.token && !options.password) {
-    // no intention to authenticate
-    return;
-  }
-  if (!options.username || !options.token) {
-    throw new Error(
-      "TCP transport requires a username and a private key for authentication, " +
-      "please, specify the 'username' and 'token' config options",
-    );
+    this.log("debug", `Pending row count: ${this.pendingRowCount}`);
+    await this.tryFlush();
   }
 
-  options.auth = {
-    keyId: options.username,
-    token: options.token,
-  };
-}
-
-function constructJwk(options: SenderOptions) {
-  if (options.auth) {
-    if (!options.auth.keyId) {
-      throw new Error(
-        "Missing username, please, specify the 'keyId' property of the 'auth' config option. " +
-        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
-      );
-    }
-    if (typeof options.auth.keyId !== "string") {
-      throw new Error(
-        "Please, specify the 'keyId' property of the 'auth' config option as a string. " +
-        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
-      );
-    }
-    if (!options.auth.token) {
-      throw new Error(
-        "Missing private key, please, specify the 'token' property of the 'auth' config option. " +
-        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
-      );
-    }
-    if (typeof options.auth.token !== "string") {
-      throw new Error(
-        "Please, specify the 'token' property of the 'auth' config option as a string. " +
-        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
-      );
+  private resetAutoFlush(): void {
+    this.lastFlushTime = Date.now();
+    this.pendingRowCount = 0;
+    this.log("debug", `Pending row count: ${this.pendingRowCount}`);
+  }
+
+  private async tryFlush() {
+    if (
+      this.autoFlush &&
+      this.pendingRowCount > 0 &&
+      ((this.autoFlushRows > 0 && this.pendingRowCount >= this.autoFlushRows) ||
+        (this.autoFlushInterval > 0 &&
+          Date.now() - this.lastFlushTime >= this.autoFlushInterval))
+    ) {
+      await this.flush();
     }
-
-    return {
-      kid: options.auth.keyId,
-      d: options.auth.token,
-      ...PUBLIC_KEY,
-      kty: "EC",
-      crv: "P-256",
-    };
-  } else {
-    return options.jwk;
   }
 }
 
-export { Sender, DEFAULT_BUFFER_SIZE, DEFAULT_MAX_BUFFER_SIZE };
+export { Sender };
diff --git a/src/transport/http/base.ts b/src/transport/http/base.ts
new file mode 100644
index 0000000..5c47532
--- /dev/null
+++ b/src/transport/http/base.ts
@@ -0,0 +1,138 @@
+// @ts-check
+import { readFileSync } from "node:fs";
+import { Buffer } from "node:buffer";
+
+import { log, Logger } from "../../logging";
+import { SenderOptions, HTTP, HTTPS } from "../../options";
+import { SenderTransport } from "../index";
+import { isBoolean, isInteger } from "../../utils";
+
+const HTTP_NO_CONTENT = 204; // success
+
+const DEFAULT_HTTP_AUTO_FLUSH_ROWS = 75000;
+
+const DEFAULT_REQUEST_MIN_THROUGHPUT = 102400; // 100 KB/sec
+const DEFAULT_REQUEST_TIMEOUT = 10000; // 10 sec
+const DEFAULT_RETRY_TIMEOUT = 10000; // 10 sec
+
+/*
+We are retrying on the following response codes (copied from the Rust client):
+500:  Internal Server Error
+503:  Service Unavailable
+504:  Gateway Timeout
+
+// Unofficial extensions
+507:  Insufficient Storage
+509:  Bandwidth Limit Exceeded
+523:  Origin is Unreachable
+524:  A Timeout Occurred
+529:  Site is overloaded
+599:  Network Connect Timeout Error
+*/
+const RETRIABLE_STATUS_CODES = [500, 503, 504, 507, 509, 523, 524, 529, 599];
+
+/**
+ * Abstract base class for HTTP-based transport implementations. <br>
+ * Provides common configuration and functionality for HTTP and HTTPS protocols.
+ */
+abstract class HttpTransportBase implements SenderTransport {
+  protected readonly secure: boolean;
+  protected readonly host: string;
+  protected readonly port: number;
+
+  protected readonly username: string;
+  protected readonly password: string;
+  protected readonly token: string;
+
+  protected readonly tlsVerify: boolean;
+  protected readonly tlsCA: Buffer;
+
+  protected readonly requestMinThroughput: number;
+  protected readonly requestTimeout: number;
+  protected readonly retryTimeout: number;
+
+  protected readonly log: Logger;
+
+  /**
+   * Creates a new HttpTransportBase instance.
+   * @param options - Sender configuration options including connection and authentication details
+   * @throws Error if required protocol or host options are missing
+   */
+  protected constructor(options: SenderOptions) {
+    if (!options || !options.protocol) {
+      throw new Error("The 'protocol' option is mandatory");
+    }
+    if (!options.host) {
+      throw new Error("The 'host' option is mandatory");
+    }
+    this.log = typeof options.log === "function" ? options.log : log;
+
+    this.tlsVerify = isBoolean(options.tls_verify) ? options.tls_verify : true;
+    this.tlsCA = options.tls_ca ? readFileSync(options.tls_ca) : undefined;
+
+    this.username = options.username;
+    this.password = options.password;
+    this.token = options.token;
+    if (!options.port) {
+      options.port = 9000;
+    }
+
+    this.host = options.host;
+    this.port = options.port;
+
+    this.requestMinThroughput = isInteger(options.request_min_throughput, 0)
+      ? options.request_min_throughput
+      : DEFAULT_REQUEST_MIN_THROUGHPUT;
+    this.requestTimeout = isInteger(options.request_timeout, 1)
+      ? options.request_timeout
+      : DEFAULT_REQUEST_TIMEOUT;
+    this.retryTimeout = isInteger(options.retry_timeout, 0)
+      ? options.retry_timeout
+      : DEFAULT_RETRY_TIMEOUT;
+
+    switch (options.protocol) {
+      case HTTP:
+        this.secure = false;
+        break;
+      case HTTPS:
+        this.secure = true;
+        break;
+      default:
+        throw new Error(
+          "The 'protocol' has to be 'http' or 'https' for the HTTP transport",
+        );
+    }
+  }
+
+  /**
+   * HTTP transport does not require explicit connection establishment.
+   * @throws Error indicating connect is not required for HTTP transport
+   */
+  connect(): Promise<boolean> {
+    throw new Error("'connect()' is not required for HTTP transport");
+  }
+
+  /**
+   * HTTP transport does not require explicit connection closure.
+   * @returns Promise that resolves immediately
+   */
+  async close(): Promise<void> {}
+
+  /**
+   * Gets the default auto-flush row count for HTTP transport.
+   * @returns Default number of rows that trigger auto-flush
+   */
+  getDefaultAutoFlushRows(): number {
+    return DEFAULT_HTTP_AUTO_FLUSH_ROWS;
+  }
+
+  /**
+   * Sends data to the QuestDB server via HTTP.
+   * Must be implemented by concrete HTTP transport classes.
+   * @param data - Buffer containing the data to send
+   * @returns Promise resolving to true if data was sent successfully
+   */
+  abstract send(data: Buffer): Promise<boolean>;
+}
+
+export { HttpTransportBase, RETRIABLE_STATUS_CODES, HTTP_NO_CONTENT };
diff --git a/src/transport/http/stdlib.ts b/src/transport/http/stdlib.ts
new file mode 100644
index 0000000..8717c41
--- /dev/null
+++ b/src/transport/http/stdlib.ts
@@ -0,0 +1,206 @@
+// @ts-check
+import http from "http";
+import https from "https";
+import { Buffer } from "node:buffer";
+
+import { SenderOptions, HTTP, HTTPS } from "../../options";
+import {
+  HttpTransportBase,
+  RETRIABLE_STATUS_CODES,
+  HTTP_NO_CONTENT,
+} from "./base";
+
+/**
+ * Default configuration for HTTP agents.
+ * - Persistent connections with 1 minute idle timeout
+ * - Maximum of 256 open connections (matching server default)
+ */
+const DEFAULT_HTTP_AGENT_CONFIG = {
+  maxSockets: 256,
+  keepAlive: true,
+  timeout: 60000, // 1 min
+};
+
+/**
+ * HTTP transport implementation using Node.js built-in http/https modules. <br>
+ * Supports both HTTP and HTTPS protocols with configurable authentication.
+ */
+class HttpTransport extends HttpTransportBase {
+  private static DEFAULT_HTTP_AGENT: http.Agent;
+  private static DEFAULT_HTTPS_AGENT: https.Agent;
+
+  private readonly agent: http.Agent | https.Agent;
+
+  /**
+   * Creates a new HttpTransport instance using Node.js HTTP modules.
+   *
+   * @param options - Sender configuration object containing connection details
+   * @throws Error if the protocol is not 'http' or 'https'
+   */
+  constructor(options: SenderOptions) {
+    super(options);
+
+    switch (options.protocol) {
+      case HTTP:
+        this.agent =
+          options.agent instanceof http.Agent
+            ? options.agent
+            : HttpTransport.getDefaultHttpAgent();
+        break;
+      case HTTPS:
+        this.agent =
+          options.agent instanceof https.Agent
+            ? options.agent
+            : HttpTransport.getDefaultHttpsAgent();
+        break;
+      default:
+        throw new Error(
+          "The 'protocol' has to be 'http' or 'https' for the HTTP transport",
+        );
+    }
+  }
+
+  /**
+   * Sends data to QuestDB using HTTP POST.
+   * @param data - Buffer containing data to send
+   * @param retryBegin - Internal parameter for tracking retry start time
+   * @param retryInterval - Internal parameter for tracking retry intervals
+   * @returns Promise resolving to true if data was sent successfully
+   * @throws Error if request fails after all retries or times out
+   */
+  send(data: Buffer, retryBegin = -1, retryInterval = -1): Promise<boolean> {
+    const request = this.secure ? https.request : http.request;
+
+    const timeoutMillis =
+      (data.length / this.requestMinThroughput) * 1000 + this.requestTimeout;
+    const options = this.createRequestOptions(timeoutMillis);
+
+    return new Promise((resolve, reject) => {
+      let statusCode = -1;
+      const req = request(options, (response) => {
+        statusCode = response.statusCode;
+
+        const body = [];
+        response
+          .on("data", (chunk) => {
+            body.push(chunk);
+          })
+          .on("error", (err) => {
+            this.log("error", `resp err=${err}`);
+          });
+
+        if (statusCode === HTTP_NO_CONTENT) {
+          response.on("end", () => {
+            if (body.length > 0) {
+              const message = Buffer.concat(body).toString();
+              const logMessage =
+                message.length < 256
+                  ? message
+                  : `${message.substring(0, 256)}... (truncated, full length=${message.length})`;
+              this.log("warn", `Unexpected message from server: ${logMessage}`);
+            }
+            resolve(true);
+          });
+        } else {
+          req.destroy(
+            new Error(
+              `HTTP request failed, statusCode=${statusCode}, error=${Buffer.concat(body)}`,
+            ),
+          );
+        }
+      });
+
+      if (this.token) {
+        req.setHeader("Authorization", `Bearer ${this.token}`);
+      } else if (this.username && this.password) {
+        req.setHeader(
+          "Authorization",
+          `Basic ${Buffer.from(`${this.username}:${this.password}`).toString("base64")}`,
+        );
+      }
+
+      req.on("timeout", () => {
+        // set a retryable error code
+        statusCode = 524;
+        req.destroy(
+          new Error("HTTP request timeout, no response from server in time"),
+        );
+      });
+      req.on("error", (err) => {
+        // if the error is thrown while the request is sent, statusCode is -1 => no retry
+        // request timeout comes through with statusCode 524 => retry
+        // if the error is thrown while the response is processed, the statusCode is taken from the response => retry depends on statusCode
+        if (isRetryable(statusCode) && this.retryTimeout > 0) {
+          if (retryBegin < 0) {
+            retryBegin = Date.now();
+            retryInterval = 10;
+          } else {
+            const elapsed = Date.now() - retryBegin;
+            if (elapsed > this.retryTimeout) {
+              reject(err);
+              return;
+            }
+          }
+          const jitter = Math.floor(Math.random() * 10) - 5;
+          setTimeout(() => {
+            retryInterval = Math.min(retryInterval * 2, 1000);
+            this.send(data, retryBegin, retryInterval)
+              .then(() => resolve(true))
+              .catch((e) => reject(e));
+          }, retryInterval + jitter);
+        } else {
+          reject(err);
+        }
+      });
+      req.write(data, (err) => (err ? reject(err) : () => {}));
+      req.end();
+    });
+  }
+
+  private createRequestOptions(
+    timeoutMillis: number,
+  ): http.RequestOptions | https.RequestOptions {
+    return {
+      hostname: this.host,
+      port: this.port,
+      agent: this.agent,
+      path: "/write?precision=n",
+      method: "POST",
+      timeout: timeoutMillis,
+      rejectUnauthorized: this.secure && this.tlsVerify,
+      ca: this.secure ? this.tlsCA : undefined,
+    };
+  }
+
+  /**
+   * @ignore
+   * @return {http.Agent} Returns the default http agent.
+   */
+  private static getDefaultHttpAgent(): http.Agent {
+    if (!HttpTransport.DEFAULT_HTTP_AGENT) {
+      HttpTransport.DEFAULT_HTTP_AGENT = new http.Agent(
+        DEFAULT_HTTP_AGENT_CONFIG,
+      );
+    }
+    return HttpTransport.DEFAULT_HTTP_AGENT;
+  }
+
+  /**
+   * @ignore
+   * @return {https.Agent} Returns the default https agent.
+   */
+  private static getDefaultHttpsAgent(): https.Agent {
+    if (!HttpTransport.DEFAULT_HTTPS_AGENT) {
+      HttpTransport.DEFAULT_HTTPS_AGENT = new https.Agent(
+        DEFAULT_HTTP_AGENT_CONFIG,
+      );
+    }
+    return HttpTransport.DEFAULT_HTTPS_AGENT;
+  }
+}
+
+function isRetryable(statusCode: number) {
+  return RETRIABLE_STATUS_CODES.includes(statusCode);
+}
+
+export { HttpTransport, HttpTransportBase };
diff --git a/src/transport/http/undici.ts b/src/transport/http/undici.ts
new file mode 100644
index 0000000..9d22349
--- /dev/null
+++ b/src/transport/http/undici.ts
@@ -0,0 +1,169 @@
+// @ts-check
+import { Buffer } from "node:buffer";
+import { Agent, RetryAgent } from "undici";
+import Dispatcher from "undici/types/dispatcher";
+
+import { SenderOptions, HTTP, HTTPS } from "../../options";
+import {
+  HttpTransportBase,
+  RETRIABLE_STATUS_CODES,
+  HTTP_NO_CONTENT,
+} from "./base";
+
+/**
+ * Default HTTP options for the Undici agent.
+ * Configures keep-alive connections with 60-second timeout and single request pipelining.
+ */
+const DEFAULT_HTTP_OPTIONS: Agent.Options = {
+  connect: {
+    keepAlive: true,
+  },
+  pipelining: 1,
+  keepAliveTimeout: 60000, // 1 minute
+};
+
+/**
+ * HTTP transport implementation using the Undici library. <br>
+ * Provides high-performance HTTP requests with connection pooling and retry logic. <br>
+ * Supports both HTTP and HTTPS protocols with configurable authentication.
+ */
+class UndiciTransport extends HttpTransportBase {
+  private static DEFAULT_HTTP_AGENT: Agent;
+
+  private readonly agent: Dispatcher;
+  private readonly dispatcher: RetryAgent;
+
+  /**
+   * Creates a new UndiciTransport instance.
+   *
+   * @param options - Sender configuration object containing connection and retry settings
+   * @throws Error if the protocol is not 'http' or 'https'
+   */
+  constructor(options: SenderOptions) {
+    super(options);
+
+    switch (options.protocol) {
+      case HTTP:
+        this.agent =
+          options.agent instanceof Agent
+            ? options.agent
+            : UndiciTransport.getDefaultHttpAgent();
+        break;
+      case HTTPS:
+        if (options.agent instanceof Agent) {
+          this.agent = options.agent;
+        } else {
+          // Create a new agent with instance-specific TLS options
+          this.agent = new Agent({
+            ...DEFAULT_HTTP_OPTIONS,
+            connect: {
+              ...DEFAULT_HTTP_OPTIONS.connect,
+              requestCert: this.tlsVerify,
+              rejectUnauthorized: this.tlsVerify,
+              ca: this.tlsCA,
+            },
+          });
+        }
+        break;
+      default:
+        throw new Error(
+          "The 'protocol' has to be 'http' or 'https' for the Undici HTTP transport",
+        );
+    }
+
+    this.dispatcher = new RetryAgent(this.agent, {
+      maxRetries: Infinity,
+      minTimeout: 10,
+      maxTimeout: 1000,
+      timeoutFactor: 2,
+      retryAfter: true,
+      methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"],
+      statusCodes: RETRIABLE_STATUS_CODES,
+      errorCodes: [
+        "ECONNRESET",
+        "EAI_AGAIN",
+        "ECONNREFUSED",
+        "ETIMEDOUT",
+        "EPIPE",
+        "UND_ERR_CONNECT_TIMEOUT",
+        "UND_ERR_HEADERS_TIMEOUT",
+        "UND_ERR_BODY_TIMEOUT",
+      ],
+    });
+  }
+
+  /**
+   * Sends data to QuestDB using HTTP POST.
+   * @param data - Buffer containing data to send
+   * @returns Promise resolving to true if data was sent successfully
+   * @throws Error if request fails after all retries or times out
+   */
+  async send(data: Buffer): Promise<boolean> {
+    const headers: Record<string, string> = {};
+    if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    } else if (this.username && this.password) {
+      headers["Authorization"] =
+        `Basic ${Buffer.from(`${this.username}:${this.password}`).toString("base64")}`;
+    }
+
+    const controller = new AbortController();
+    const { signal } = controller;
+    setTimeout(() => controller.abort(), this.retryTimeout);
+
+    let responseData: Dispatcher.ResponseData;
+    try {
+      const timeoutMillis =
+        (data.length / this.requestMinThroughput) * 1000 + this.requestTimeout;
+      responseData = await this.dispatcher.request({
+        origin: `${this.secure ? "https" : "http"}://${this.host}:${this.port}`,
+        path: "/write?precision=n",
+        method: "POST",
+        headers,
+        body: data,
+        headersTimeout: this.requestTimeout,
+        bodyTimeout: timeoutMillis,
+        signal,
+      });
+    } catch (err) {
+      if (err.name === "AbortError") {
+        throw new Error(
+          "HTTP request timeout, no response from server in time",
+        );
+      } else {
+        throw err;
+      }
+    }
+
+    const { statusCode } = responseData;
+    const body = await responseData.body.arrayBuffer();
+    if (statusCode === HTTP_NO_CONTENT) {
+      if (body.byteLength > 0) {
+        const message = Buffer.from(body).toString();
+        const logMessage =
+          message.length < 256
+            ? message
+            : `${message.substring(0, 256)}... (truncated, full length=${message.length})`;
+        this.log("warn", `Unexpected message from server: ${logMessage}`);
+      }
+      return true;
+    } else {
+      throw new Error(
+        `HTTP request failed, statusCode=${statusCode}, error=${Buffer.from(body).toString()}`,
+      );
+    }
+  }
+
+  /**
+   * @ignore
+   * @return {Agent} Returns the default http agent.
+   */
+  private static getDefaultHttpAgent(): Agent {
+    if (!UndiciTransport.DEFAULT_HTTP_AGENT) {
+      UndiciTransport.DEFAULT_HTTP_AGENT = new Agent(DEFAULT_HTTP_OPTIONS);
+    }
+    return UndiciTransport.DEFAULT_HTTP_AGENT;
+  }
+}
+
+export { UndiciTransport };
diff --git a/src/transport/index.ts b/src/transport/index.ts
new file mode 100644
index 0000000..380040a
--- /dev/null
+++ b/src/transport/index.ts
@@ -0,0 +1,70 @@
+// @ts-check
+import { Buffer } from "node:buffer";
+
+import { SenderOptions, HTTP, HTTPS, TCP, TCPS } from "../options";
+import { UndiciTransport } from "./http/undici";
+import { TcpTransport } from "./tcp";
+import { HttpTransport } from "./http/stdlib";
+
+/**
+ * Interface for QuestDB transport implementations. <br>
+ * Defines the contract for different transport protocols (HTTP/HTTPS/TCP/TCPS).
+ */
+interface SenderTransport {
+  /**
+   * Establishes a connection to the database server. <br>
+   * Should not be called on HTTP transports.
+   * @returns Promise resolving to true if connection is successful
+   */
+  connect(): Promise<boolean>;
+
+  /**
+   * Sends buffered data to the database server.
+   * @param data - Buffer containing the data to send
+   * @returns Promise resolving to true if data was sent successfully
+   */
+  send(data: Buffer): Promise<boolean>;
+
+  /**
+   * Closes the connection to the database server. <br>
+   * Should not be called on HTTP transports.
+   * @returns Promise that resolves when the connection is closed
+   */
+  close(): Promise<void>;
+
+  /**
+   * Gets the default number of rows that trigger auto-flush for this transport.
+   * @returns Default auto-flush row count
+   */
+  getDefaultAutoFlushRows(): number;
+}
+
+/**
+ * Factory function to create appropriate transport instance based on configuration.
+ * @param options - Sender configuration options including protocol and connection details
+ * @returns Transport instance appropriate for the specified protocol
+ * @throws Error if protocol or host options are missing or invalid
+ */
+function createTransport(options: SenderOptions): SenderTransport {
+  if (!options || !options.protocol) {
+    throw new Error("The 'protocol' option is mandatory");
+  }
+  if (!options.host) {
+    throw new Error("The 'host' option is mandatory");
+  }
+
+  switch (options.protocol) {
+    case HTTP:
+    case HTTPS:
+      return options.stdlib_http
+        ? new HttpTransport(options)
+        : new UndiciTransport(options);
+    case TCP:
+    case TCPS:
+      return new TcpTransport(options);
+    default:
+      throw new Error(`Invalid protocol: '${options.protocol}'`);
+  }
+}
+
+export { SenderTransport, createTransport };
diff --git a/src/transport/tcp.ts b/src/transport/tcp.ts
new file mode 100644
index 0000000..bc84464
--- /dev/null
+++ b/src/transport/tcp.ts
@@ -0,0 +1,281 @@
+// @ts-check
+import { readFileSync } from "node:fs";
+import { Buffer } from "node:buffer";
+import net from "node:net";
+import tls from "node:tls";
+import crypto from "node:crypto";
+
+import { log, Logger } from "../logging";
+import { SenderOptions, TCP, TCPS } from "../options";
+import { SenderTransport } from "./index";
+import { isBoolean } from "../utils";
+
+const DEFAULT_TCP_AUTO_FLUSH_ROWS = 600;
+
+// Arbitrary public key, used to construct valid JWK tokens.
+// These are not used for actual authentication, only required for crypto API compatibility.
+const PUBLIC_KEY = {
+  x: "aultdA0PjhD_cWViqKKyL5chm6H1n-BiZBo_48T-uqc",
+  y: "__ptaol41JWSpTTL525yVEfzmY8A6Vi_QrW1FjKcHMg",
+};
+
+/**
+ * TCP transport implementation. <br>
+ * Supports both plain TCP or secure TLS-encrypted connections with configurable JWK token authentication.
+ */
+class TcpTransport implements SenderTransport {
+  private readonly secure: boolean;
+  private readonly host: string;
+  private readonly port: number;
+
+  private socket: net.Socket | tls.TLSSocket;
+
+  private readonly tlsVerify: boolean;
+  private readonly tlsCA: Buffer;
+
+  private readonly log: Logger;
+  private readonly jwk: Record<string, string>;
+
+  /**
+   * Creates a new TcpTransport instance.
+   *
+   * @param options - Sender configuration object containing connection and authentication details
+   * @throws Error if required options are missing or protocol is not 'tcp' or 'tcps'
+   */
+  constructor(options: SenderOptions) {
+    if (!options || !options.protocol) {
+      throw new Error("The 'protocol' option is mandatory");
+    }
+    if (!options.host) {
+      throw new Error("The 'host' option is mandatory");
+    }
+    this.log = typeof options.log === "function" ? options.log : log;
+
+    this.tlsVerify = isBoolean(options.tls_verify) ? options.tls_verify : true;
+    this.tlsCA = options.tls_ca ? readFileSync(options.tls_ca) : undefined;
+
+    this.host = options.host;
+    this.port = options.port;
+
+    switch (options.protocol) {
+      case TCP:
+        this.secure = false;
+        break;
+      case TCPS:
+        this.secure = true;
+        break;
+      default:
+        throw new Error(
+          "The 'protocol' has to be 'tcp' or 'tcps' for the TCP transport",
+        );
+    }
+
+    if (!options.auth && !options.jwk) {
+      constructAuth(options);
+    }
+    this.jwk = constructJwk(options);
+    if (!options.port) {
+      options.port = 9009;
+    }
+  }
+
+  /**
+   * Creates a TCP connection to the database.
+   * @returns Promise resolving to true if the connection is established successfully
+   * @throws Error if connection fails or authentication is rejected
+   */
+  connect(): Promise<boolean> {
+    const connOptions: net.NetConnectOpts | tls.ConnectionOptions = {
+      host: this.host,
+      port: this.port,
+      ca: this.tlsCA,
+    };
+
+    return new Promise((resolve, reject) => {
+      if (this.socket) {
+        throw new Error("Sender connected already");
+      }
+
+      let authenticated: boolean = false;
+      let data: Buffer;
+
+      this.socket = !this.secure
+        ? net.connect(connOptions as net.NetConnectOpts)
+        : tls.connect(connOptions as tls.ConnectionOptions, () => {
+            if (authenticated) {
+              resolve(true);
+            }
+          });
+      this.socket.setKeepAlive(true);
+
+      this.socket
+        .on("data", async (raw) => {
+          data = !data ? raw : Buffer.concat([data, raw]);
+          if (!authenticated) {
+            authenticated = await this.authenticate(data);
+            if (authenticated) {
+              resolve(true);
+            }
+          } else {
+            this.log("warn", `Received unexpected data: ${data}`);
+          }
+        })
+        .on("ready", async () => {
+          this.log(
+            "info",
+            `Successfully connected to ${connOptions.host}:${connOptions.port}`,
+          );
+          if (this.jwk) {
+            this.log(
+              "info",
+              `Authenticating with ${connOptions.host}:${connOptions.port}`,
+            );
+            this.socket.write(`${this.jwk.kid}\n`, (err) =>
+              err ? reject(err) : () => {},
+            );
+          } else {
+            authenticated = true;
+            if (!this.secure || !this.tlsVerify) {
+              resolve(true);
+            }
+          }
+        })
+        .on("error", (err: Error & { code: string }) => {
+          this.log("error", err);
+          if (
+            this.tlsVerify ||
+            !err.code ||
+            err.code !== "SELF_SIGNED_CERT_IN_CHAIN"
+          ) {
+            reject(err);
+          }
+        });
+    });
+  }
+
+  /**
+   * Sends data over the established TCP connection.
+   * @param data - Buffer containing the data to send
+   * @returns Promise resolving to true if data was sent successfully
+   * @throws Error if the data could not be written to the socket
+   */
+  send(data: Buffer): Promise<boolean> {
+    if (!this.socket || this.socket.destroyed) {
+      throw new Error("TCP transport is not connected");
+    }
+    return new Promise((resolve, reject) => {
+      this.socket.write(data, (err: Error) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(true);
+        }
+      });
+    });
+  }
+
+  /**
+   * Closes the TCP connection to the database. <br>
+   */
+  async close(): Promise<void> {
+    if (this.socket) {
+      const address = this.socket.remoteAddress;
+      const port = this.socket.remotePort;
+      this.socket.destroy();
+      this.socket = null;
+      this.log("info", `Connection to ${address}:${port} is closed`);
+    }
+  }
+
+  getDefaultAutoFlushRows(): number {
+    return DEFAULT_TCP_AUTO_FLUSH_ROWS;
+  }
+
+  private async authenticate(challenge: Buffer): Promise<boolean> {
+    // Check for trailing \n which ends the challenge
+    if (challenge.subarray(-1).readInt8() === 10) {
+      const keyObject = crypto.createPrivateKey({
+        key: this.jwk,
+        format: "jwk",
+      });
+      const signature = crypto.sign(
+        "RSA-SHA256",
+        challenge.subarray(0, challenge.length - 1),
+        keyObject,
+      );
+
+      return new Promise((resolve, reject) => {
+        this.socket.write(
+          `${Buffer.from(signature).toString("base64")}\n`,
+          (err: Error) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(true);
+            }
+          },
+        );
+      });
+    }
+    return false;
+  }
+}
+
+function constructAuth(options: SenderOptions) {
+  if (!options.username && !options.token && !options.password) {
+    // no intention to authenticate
+    return;
+  }
+  if (!options.username || !options.token) {
+    throw new Error(
+      "TCP transport requires a username and a private key for authentication, " +
+        "please, specify the 'username' and 'token' config options",
+    );
+  }
+
+  options.auth = {
+    keyId: options.username,
+    token: options.token,
+  };
+}
+
+function constructJwk(options: SenderOptions) {
+  if (options.auth) {
+    if (!options.auth.keyId) {
+      throw new Error(
+        "Missing username, please, specify the 'keyId' property of the 'auth' config option. " +
+          "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
+      );
+    }
+    if (typeof options.auth.keyId !== "string") {
+      throw new Error(
+        "Please, specify the 'keyId' property of the 'auth' config option as a string. " +
+          "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
+      );
+    }
+    if (!options.auth.token) {
+      throw new Error(
+        "Missing private key, please, specify the 'token' property of the 'auth' config option. " +
+          "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
+      );
+    }
+    if (typeof options.auth.token !== "string") {
+      throw new Error(
+        "Please, specify the 'token' property of the 'auth' config option as a string. " +
+          "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
+      );
+    }
+
+    return {
+      kid: options.auth.keyId,
+      d: options.auth.token,
+      ...PUBLIC_KEY,
+      kty: "EC",
+      crv: "P-256",
+    };
+  } else {
+    return options.jwk;
+  }
+}
+
+export { TcpTransport };
diff --git a/src/utils.ts b/src/utils.ts
new file mode 100644
index 0000000..e4e67fa
--- /dev/null
+++ b/src/utils.ts
@@ -0,0 +1,45 @@
+type TimestampUnit = "ns" | "us" | "ms";
+
+function isBoolean(value: unknown): value is boolean {
+  return typeof value === "boolean";
+}
+
+function isInteger(value: unknown, lowerBound: number): value is number {
+  return (
+    typeof value === "number" && Number.isInteger(value) && value >= lowerBound
+  );
+}
+
+function timestampToMicros(timestamp: bigint, unit: TimestampUnit) {
+  switch (unit) {
+    case "ns":
+      return timestamp / 1000n;
+    case "us":
+      return timestamp;
+    case "ms":
+      return timestamp * 1000n;
+    default:
+      throw new Error(`Unknown timestamp unit: ${unit}`);
+  }
+}
+
+function timestampToNanos(timestamp: bigint, unit: TimestampUnit) {
+  switch (unit) {
+    case "ns":
+      return timestamp;
+    case "us":
+      return timestamp * 1000n;
+    case "ms":
+      return timestamp * 1000_000n;
+    default:
+      throw new Error(`Unknown timestamp unit: ${unit}`);
+  }
+}
+
+export {
+  isBoolean,
+  isInteger,
+  timestampToMicros,
+  timestampToNanos,
+  TimestampUnit,
+};
diff --git a/test/_utils_/mockhttp.ts b/test/_utils_/mockhttp.ts
deleted file mode 100644
index 8487bc0..0000000
--- a/test/_utils_/mockhttp.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-import http from "node:http";
-import https from "node:https";
-
-class MockHttp {
-  server: http.Server | https.Server;
-  mockConfig: {
-    responseDelays?: number[],
-    responseCodes?: number[],
-    username?: string,
-    password?: string,
-    token?: string,
-  };
-  numOfRequests: number;
-
-  constructor() {
-    this.reset();
-  }
-
-  reset(mockConfig = {}) {
-    this.mockConfig = mockConfig;
-    this.numOfRequests = 0;
-  }
-
-  async start(listenPort: number, secure: boolean = false, options?: Record<string, unknown>) {
-    const serverCreator = secure ? https.createServer : http.createServer;
-    // @ts-expect-error - Testing different options, so typing is not important
-    this.server = serverCreator(options, (req, res) => {
-      const authFailed = checkAuthHeader(this.mockConfig, req);
-
-      const body: Uint8Array[] = [];
-      req.on("data", (chunk: Uint8Array) => {
-        body.push(chunk);
-      });
-
-      req.on("end", async () => {
-        console.info(`Received data: ${Buffer.concat(body)}`);
-        this.numOfRequests++;
-
-        const delay =
-          this.mockConfig.responseDelays &&
-            this.mockConfig.responseDelays.length > 0
-            ? this.mockConfig.responseDelays.pop()
-            : undefined;
-        if (delay) {
-          await sleep(delay);
-        }
-
-        const responseCode = authFailed
-          ? 401
-          : this.mockConfig.responseCodes &&
-            this.mockConfig.responseCodes.length > 0
-            ? this.mockConfig.responseCodes.pop()
-            : 204;
-        res.writeHead(responseCode);
-        res.end();
-      });
-    });
-
-    this.server.listen(listenPort, () => {
-      console.info(`Server is running on port ${listenPort}`);
-    });
-  }
-
-  async stop() {
-    if (this.server) {
-      this.server.close();
-    }
-  }
-}
-
-function checkAuthHeader(mockConfig, req) {
-  let authFailed = false;
-  const header = (req.headers.authorization || "").split(/\s+/);
-  switch (header[0]) {
-    case "Basic": {
-      const auth = Buffer.from(header[1], "base64").toString().split(/:/);
-      if (mockConfig.username !== auth[0] || mockConfig.password !== auth[1]) {
-        authFailed = true;
-      }
-      break;
-    }
-    case "Bearer":
-      if (mockConfig.token !== header[1]) {
-        authFailed = true;
-      }
-      break;
-    default:
-      if (mockConfig.username || mockConfig.password || mockConfig.token) {
-        authFailed = true;
-      }
-  }
-  return authFailed;
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export { MockHttp };
diff --git a/test/logging.test.ts b/test/logging.test.ts
index 4384e60..6e17e34 100644
--- a/test/logging.test.ts
+++ b/test/logging.test.ts
@@ -1,3 +1,4 @@
+// @ts-check
 import {
   describe,
   it,
@@ -8,15 +9,14 @@ import {
   vi,
 } from "vitest";
 
+import { Logger } from "../src/logging";
+
 describe("Default logging suite", function () {
-  const error = vi.spyOn(console, "error").mockImplementation(() => { });
-  const warn = vi.spyOn(console, "warn").mockImplementation(() => { });
-  const info = vi.spyOn(console, "info").mockImplementation(() => { });
-  const debug = vi.spyOn(console, "debug").mockImplementation(() => { });
-  let log: (
-    level: "error" | "warn" | "info" | "debug",
-    message: string,
-  ) => void;
+  const error = vi.spyOn(console, "error").mockImplementation(() => {});
+  const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+  const info = vi.spyOn(console, "info").mockImplementation(() => {});
+  const debug = vi.spyOn(console, "debug").mockImplementation(() => {});
+  let log: Logger;
 
   beforeAll(async () => {
     log = (await import("../src/logging")).log;
@@ -66,7 +66,7 @@ describe("Default logging suite", function () {
     expect(info).toHaveBeenCalledWith(testMessage);
   });
 
-  it("cannot log debug level messages", function () {
+  it("cannot log debug level messages, default logging level is 'info'", function () {
     const testMessage = "DEBUG DEBUG DEBUG";
     log("debug", testMessage);
     expect(error).toHaveBeenCalledTimes(0);
diff --git a/test/options.test.ts b/test/options.test.ts
index 576670c..e8be4e5 100644
--- a/test/options.test.ts
+++ b/test/options.test.ts
@@ -1,7 +1,9 @@
+// @ts-check
 import { describe, it, expect } from "vitest";
-import { SenderOptions } from "../src/options";
 import { Agent } from "undici";
 
+import { SenderOptions } from "../src/options";
+
 describe("Configuration string parser suite", function () {
   it("can parse a basic config string", function () {
     const options = SenderOptions.fromConfig(
@@ -688,14 +690,14 @@ describe("Configuration string parser suite", function () {
         // @ts-expect-error - Testing invalid input
         agent: { keepAlive: true },
       }),
-    ).toThrow("Invalid http/https agent");
+    ).toThrow("Invalid HTTP agent");
     expect(() =>
       // @ts-expect-error - Testing invalid input
       SenderOptions.fromConfig("http::addr=host:9000", { agent: 4567 }),
-    ).toThrow("Invalid http/https agent");
+    ).toThrow("Invalid HTTP agent");
     expect(() =>
       // @ts-expect-error - Testing invalid input
       SenderOptions.fromConfig("http::addr=host:9000", { agent: "hopp" }),
-    ).toThrow("Invalid http/https agent");
+    ).toThrow("Invalid HTTP agent");
   });
 });
diff --git a/test/sender.buffer.test.ts b/test/sender.buffer.test.ts
new file mode 100644
index 0000000..7f00f80
--- /dev/null
+++ b/test/sender.buffer.test.ts
@@ -0,0 +1,808 @@
+// @ts-check
+import { describe, it, expect } from "vitest";
+import { readFileSync } from "fs";
+
+import { Sender } from "../src";
+
+describe("Client interop test suite", function () {
+  it("runs client tests as per json test config", async function () {
+    const testCases = JSON.parse(
+      readFileSync(
+        "./questdb-client-test/ilp-client-interop-test.json",
+      ).toString(),
+    );
+
+    for (const testCase of testCases) {
+      console.info(`test name: ${testCase.testName}`);
+
+      const sender = new Sender({
+        protocol: "tcp",
+        host: "host",
+        auto_flush: false,
+        init_buf_size: 1024,
+      });
+
+      let errorMessage: string;
+      try {
+        sender.table(testCase.table);
+        for (const symbol of testCase.symbols) {
+          sender.symbol(symbol.name, symbol.value);
+        }
+        for (const column of testCase.columns) {
+          switch (column.type) {
+            case "STRING":
+              sender.stringColumn(column.name, column.value);
+              break;
+            case "LONG":
+              sender.intColumn(column.name, column.value);
+              break;
+            case "DOUBLE":
+              sender.floatColumn(column.name, column.value);
+              break;
+            case "BOOLEAN":
+              sender.booleanColumn(column.name, column.value);
+              break;
+            case "TIMESTAMP":
+              sender.timestampColumn(column.name, column.value);
+              break;
+            default:
+              errorMessage = "Unsupported column type";
+          }
+          if (errorMessage) {
+            break;
+          }
+        }
+        await sender.atNow();
+      } catch (e) {
+        if (testCase.result.status === "ERROR") {
+          // error is expected, continue to next test case
+          continue;
+        }
+        errorMessage = `Unexpected error: ${e.message}`;
+      }
+
+      if (!errorMessage) {
+        const actualLine = bufferContent(sender);
+
+        if (testCase.result.status === "SUCCESS") {
+          if (testCase.result.line) {
+            expect(actualLine).toBe(testCase.result.line + "\n");
+          } else {
+            let foundMatch = false;
+            for (const expectedLine of testCase.result.anyLines) {
+              if (actualLine === expectedLine + "\n") {
+                foundMatch = true;
+                break;
+              }
+            }
+            if (!foundMatch) {
+              errorMessage = `Line is not matching any of the expected results: ${actualLine}`;
+            }
+          }
+        } else {
+          errorMessage = `Expected error missing, buffer's content: ${actualLine}`;
+        }
+      }
+
+      await sender.close();
+      expect(errorMessage).toBeUndefined();
+    }
+  });
+});
+
+describe("Sender message builder test suite (anything not covered in client interop test suite)", function () {
+  it("throws on invalid timestamp unit", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      auto_flush: false,
+      init_buf_size: 1024,
+    });
+
+    await expect(
+      async () =>
+        await sender
+          .table("tableName")
+          .booleanColumn("boolCol", true)
+          // @ts-expect-error - Testing invalid options
+          .timestampColumn("timestampCol", 1658484765000000, "foobar")
+          .atNow(),
+    ).rejects.toThrow("Unknown timestamp unit: foobar");
+    await sender.close();
+  });
+
+  it("supports json object", async function () {
+    const pages: Array<{
+      id: string;
+      gridId: string;
+    }>[] = [];
+    for (let i = 0; i < 4; i++) {
+      const pageProducts: Array<{
+        id: string;
+        gridId: string;
+      }> = [
+        {
+          id: "46022e96-076f-457f-b630-51b82b871618" + i,
+          gridId: "46022e96-076f-457f-b630-51b82b871618",
+        },
+        {
+          id: "55615358-4af1-4179-9153-faaa57d71e55",
+          gridId: "55615358-4af1-4179-9153-faaa57d71e55",
+        },
+        {
+          id: "365b9cdf-3d4e-4135-9cb0-f1a65601c840",
+          gridId: "365b9cdf-3d4e-4135-9cb0-f1a65601c840",
+        },
+        {
+          id: "0b67ddf2-8e69-4482-bf0c-bb987ee5c280",
+          gridId: "0b67ddf2-8e69-4482-bf0c-bb987ee5c280" + i,
+        },
+      ];
+      pages.push(pageProducts);
+    }
+
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 256,
+    });
+    for (const p of pages) {
+      await sender
+        .table("tableName")
+        .stringColumn("page_products", JSON.stringify(p || []))
+        .booleanColumn("boolCol", true)
+        .atNow();
+    }
+    expect(bufferContent(sender)).toBe(
+      'tableName page_products="[{\\"id\\":\\"46022e96-076f-457f-b630-51b82b8716180\\",\\"gridId\\":\\"46022e96-076f-457f-b630-51b82b871618\\"},{\\"id\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\",\\"gridId\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\"},{\\"id\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\",\\"gridId\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\"},{\\"id\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c280\\",\\"gridId\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c2800\\"}]",boolCol=t\n' +
+        'tableName page_products="[{\\"id\\":\\"46022e96-076f-457f-b630-51b82b8716181\\",\\"gridId\\":\\"46022e96-076f-457f-b630-51b82b871618\\"},{\\"id\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\",\\"gridId\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\"},{\\"id\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\",\\"gridId\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\"},{\\"id\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c280\\",\\"gridId\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c2801\\"}]",boolCol=t\n' +
+        'tableName page_products="[{\\"id\\":\\"46022e96-076f-457f-b630-51b82b8716182\\",\\"gridId\\":\\"46022e96-076f-457f-b630-51b82b871618\\"},{\\"id\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\",\\"gridId\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\"},{\\"id\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\",\\"gridId\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\"},{\\"id\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c280\\",\\"gridId\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c2802\\"}]",boolCol=t\n' +
+        'tableName page_products="[{\\"id\\":\\"46022e96-076f-457f-b630-51b82b8716183\\",\\"gridId\\":\\"46022e96-076f-457f-b630-51b82b871618\\"},{\\"id\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\",\\"gridId\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\"},{\\"id\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\",\\"gridId\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\"},{\\"id\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c280\\",\\"gridId\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c2803\\"}]",boolCol=t\n',
+    );
+    await sender.close();
+  });
+
+  it("supports timestamp field as number", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000000)
+      .atNow();
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t\n",
+    );
+    await sender.close();
+  });
+
+  it("supports timestamp field as ns number", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000000, "ns")
+      .atNow();
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000t\n",
+    );
+    await sender.close();
+  });
+
+  it("supports timestamp field as us number", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000000, "us")
+      .atNow();
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t\n",
+    );
+    await sender.close();
+  });
+
+  it("supports timestamp field as ms number", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000, "ms")
+      .atNow();
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t\n",
+    );
+    await sender.close();
+  });
+
+  it("supports timestamp field as BigInt", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000000n)
+      .atNow();
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t\n",
+    );
+    await sender.close();
+  });
+
+  it("supports timestamp field as ns BigInt", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000000000n, "ns")
+      .atNow();
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t\n",
+    );
+    await sender.close();
+  });
+
+  it("supports timestamp field as us BigInt", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000000n, "us")
+      .atNow();
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t\n",
+    );
+    await sender.close();
+  });
+
+  it("supports timestamp field as ms BigInt", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000n, "ms")
+      .atNow();
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t\n",
+    );
+    await sender.close();
+  });
+
+  it("throws on invalid designated timestamp unit", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    try {
+      await sender
+        .table("tableName")
+        .booleanColumn("boolCol", true)
+        .timestampColumn("timestampCol", 1658484765000000)
+        // @ts-expect-error - Testing invalid options
+        .at(1658484769000000, "foobar");
+    } catch (err) {
+      expect(err.message).toBe("Unknown timestamp unit: foobar");
+    }
+    await sender.close();
+  });
+
+  it("supports setting designated us timestamp as number from client", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000000)
+      .at(1658484769000000, "us");
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t 1658484769000000000\n",
+    );
+    await sender.close();
+  });
+
+  it("supports setting designated ms timestamp as number from client", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000000)
+      .at(1658484769000, "ms");
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t 1658484769000000000\n",
+    );
+    await sender.close();
+  });
+
+  it("supports setting designated timestamp as BigInt from client", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000000)
+      .at(1658484769000000n);
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t 1658484769000000000\n",
+    );
+    await sender.close();
+  });
+
+  it("supports setting designated ns timestamp as BigInt from client", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000000)
+      .at(1658484769000000123n, "ns");
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t 1658484769000000123\n",
+    );
+    await sender.close();
+  });
+
+  it("supports setting designated us timestamp as BigInt from client", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000000)
+      .at(1658484769000000n, "us");
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t 1658484769000000000\n",
+    );
+    await sender.close();
+  });
+
+  it("supports setting designated ms timestamp as BigInt from client", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000000)
+      .at(1658484769000n, "ms");
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t 1658484769000000000\n",
+    );
+    await sender.close();
+  });
+
+  it("throws exception if table name is not a string", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    // @ts-expect-error - Invalid options
+    expect(() => sender.table(23456)).toThrow(
+      "Table name must be a string, received number",
+    );
+    await sender.close();
+  });
+
+  it("throws exception if table name is too long", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    expect(() =>
+      sender.table(
+        "123456789012345678901234567890123456789012345678901234567890" +
+          "12345678901234567890123456789012345678901234567890123456789012345678",
+      ),
+    ).toThrow("Table name is too long, max length is 127");
+    await sender.close();
+  });
+
+  it("throws exception if table name is set more times", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    expect(() =>
+      sender.table("tableName").symbol("name", "value").table("newTableName"),
+    ).toThrow("Table name has already been set");
+    await sender.close();
+  });
+
+  it("throws exception if symbol name is not a string", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    // @ts-expect-error - Invalid options
+    expect(() => sender.table("tableName").symbol(12345.5656, "value")).toThrow(
+      "Symbol name must be a string, received number",
+    );
+    await sender.close();
+  });
+
+  it("throws exception if symbol name is empty string", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    expect(() => sender.table("tableName").symbol("", "value")).toThrow(
+      "Empty string is not allowed as column name",
+    );
+    await sender.close();
+  });
+
+  it("throws exception if column name is not a string", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    expect(() =>
+      // @ts-expect-error - Invalid options
+      sender.table("tableName").stringColumn(12345.5656, "value"),
+    ).toThrow("Column name must be a string, received number");
+    await sender.close();
+  });
+
+  it("throws exception if column name is empty string", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    expect(() => sender.table("tableName").stringColumn("", "value")).toThrow(
+      "Empty string is not allowed as column name",
+    );
+    await sender.close();
+  });
+
+  it("throws exception if column name is too long", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    expect(() =>
+      sender
+        .table("tableName")
+        .stringColumn(
+          "123456789012345678901234567890123456789012345678901234567890" +
+            "12345678901234567890123456789012345678901234567890123456789012345678",
+          "value",
+        ),
+    ).toThrow("Column name is too long, max length is 127");
+    await sender.close();
+  });
+
+  it("throws exception if column value is not the right type", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    expect(() =>
+      // @ts-expect-error - Invalid options
+      sender.table("tableName").stringColumn("columnName", false),
+    ).toThrow("Column value must be of type string, received boolean");
+    await sender.close();
+  });
+
+  it("throws exception if adding column without setting table name", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    expect(() => sender.floatColumn("name", 12.459)).toThrow(
+      "Column can be set only after table name is set",
+    );
+    await sender.close();
+  });
+
+  it("throws exception if adding symbol without setting table name", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    expect(() => sender.symbol("name", "value")).toThrow(
+      "Symbol can be added only after table name is set and before any column added",
+    );
+    await sender.close();
+  });
+
+  it("throws exception if adding symbol after columns", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    expect(() =>
+      sender
+        .table("tableName")
+        .stringColumn("name", "value")
+        .symbol("symbolName", "symbolValue"),
+    ).toThrow(
+      "Symbol can be added only after table name is set and before any column added",
+    );
+    await sender.close();
+  });
+
+  it("returns null if preparing an empty buffer for send", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    // @ts-expect-error - Accessing private field
+    expect(sender.buffer.toBufferView()).toBe(null);
+    // @ts-expect-error - Accessing private field
+    expect(sender.buffer.toBufferNew()).toBe(null);
+    await sender.close();
+  });
+
+  it("leaves unfinished rows in the sender's buffer when preparing a copy of the buffer for send", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    sender.table("tableName").symbol("name", "value");
+    await sender.at(1234567890n, "ns");
+    sender.table("tableName").symbol("name", "value2");
+
+    // copy of the sender's buffer contains the finished row
+    // @ts-expect-error - Accessing private field
+    expect(sender.buffer.toBufferNew().toString()).toBe(
+      "tableName,name=value 1234567890\n",
+    );
+    // the sender's buffer is compacted, and contains only the unfinished row
+    // @ts-expect-error - Accessing private field
+    expect(sender.buffer.toBufferView(bufferPosition(sender)).toString()).toBe(
+      "tableName,name=value2",
+    );
+    await sender.close();
+  });
+
+  it("throws exception if a float is passed as integer field", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    expect(() =>
+      sender.table("tableName").intColumn("intField", 123.222),
+    ).toThrow("Value must be an integer, received 123.222");
+    await sender.close();
+  });
+
+  it("throws exception if a float is passed as timestamp field", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    expect(() =>
+      sender.table("tableName").timestampColumn("intField", 123.222),
+    ).toThrow("Value must be an integer or BigInt, received 123.222");
+    await sender.close();
+  });
+
+  it("throws exception if designated timestamp is not an integer or bigint", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    try {
+      await sender
+        .table("tableName")
+        .symbol("name", "value")
+        .at(23232322323.05);
+    } catch (e) {
+      expect(e.message).toEqual(
+        "Designated timestamp must be an integer or BigInt, received 23232322323.05",
+      );
+    }
+    await sender.close();
+  });
+
+  it("throws exception if designated timestamp is invalid", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    try {
+      // @ts-expect-error - Invalid options
+      await sender.table("tableName").symbol("name", "value").at("invalid_dts");
+    } catch (e) {
+      expect(e.message).toEqual(
+        "Designated timestamp must be an integer or BigInt, received invalid_dts",
+      );
+    }
+    await sender.close();
+  });
+
+  it("throws exception if designated timestamp is set without any fields added", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    try {
+      await sender.table("tableName").at(12345678n, "ns");
+    } catch (e) {
+      expect(e.message).toEqual(
+        "The row must have a symbol or column set before it is closed",
+      );
+    }
+    await sender.close();
+  });
+
+  it("extends the size of the buffer if data does not fit", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 8,
+    });
+    expect(bufferSize(sender)).toBe(8);
+    expect(bufferPosition(sender)).toBe(0);
+    sender.table("tableName");
+    expect(bufferSize(sender)).toBe(24);
+    expect(bufferPosition(sender)).toBe("tableName".length);
+    sender.intColumn("intField", 123);
+    expect(bufferSize(sender)).toBe(48);
+    expect(bufferPosition(sender)).toBe("tableName intField=123i".length);
+    await sender.atNow();
+    expect(bufferSize(sender)).toBe(48);
+    expect(bufferPosition(sender)).toBe("tableName intField=123i\n".length);
+    expect(bufferContent(sender)).toBe("tableName intField=123i\n");
+
+    await sender
+      .table("table2")
+      .intColumn("intField", 125)
+      .stringColumn("strField", "test")
+      .atNow();
+    expect(bufferSize(sender)).toBe(96);
+    expect(bufferPosition(sender)).toBe(
+      'tableName intField=123i\ntable2 intField=125i,strField="test"\n'.length,
+    );
+    expect(bufferContent(sender)).toBe(
+      'tableName intField=123i\ntable2 intField=125i,strField="test"\n',
+    );
+    await sender.close();
+  });
+
+  it("throws exception if tries to extend the size of the buffer above max buffer size", async function () {
+    const sender = Sender.fromConfig(
+      "tcp::addr=host;init_buf_size=8;max_buf_size=64;",
+    );
+    expect(bufferSize(sender)).toBe(8);
+    expect(bufferPosition(sender)).toBe(0);
+    sender.table("tableName");
+    expect(bufferSize(sender)).toBe(24);
+    expect(bufferPosition(sender)).toBe("tableName".length);
+    sender.intColumn("intField", 123);
+    expect(bufferSize(sender)).toBe(48);
+    expect(bufferPosition(sender)).toBe("tableName intField=123i".length);
+    await sender.atNow();
+    expect(bufferSize(sender)).toBe(48);
+    expect(bufferPosition(sender)).toBe("tableName intField=123i\n".length);
+    expect(bufferContent(sender)).toBe("tableName intField=123i\n");
+
+    try {
+      await sender
+        .table("table2")
+        .intColumn("intField", 125)
+        .stringColumn("strField", "test")
+        .atNow();
+    } catch (err) {
+      expect(err.message).toBe(
+        "Max buffer size is 64 bytes, requested buffer size: 96",
+      );
+    }
+    await sender.close();
+  });
+
+  it("is possible to clear the buffer by calling reset()", async function () {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", true)
+      .timestampColumn("timestampCol", 1658484765000000)
+      .atNow();
+    await sender
+      .table("tableName")
+      .booleanColumn("boolCol", false)
+      .timestampColumn("timestampCol", 1658484766000000)
+      .atNow();
+    expect(bufferContent(sender)).toBe(
+      "tableName boolCol=t,timestampCol=1658484765000000t\n" +
+        "tableName boolCol=f,timestampCol=1658484766000000t\n",
+    );
+
+    sender.reset();
+    await sender
+      .table("tableName")
+      .floatColumn("floatCol", 1234567890)
+      .timestampColumn("timestampCol", 1658484767000000)
+      .atNow();
+    expect(bufferContent(sender)).toBe(
+      "tableName floatCol=1234567890,timestampCol=1658484767000000t\n",
+    );
+    await sender.close();
+  });
+});
+
+function bufferContent(sender: Sender) {
+  // @ts-expect-error - Accessing private field
+  return sender.buffer.toBufferView().toString();
+}
+
+function bufferSize(sender: Sender) {
+  // @ts-expect-error - Accessing private field
+  return sender.buffer.bufferSize;
+}
+
+function bufferPosition(sender: Sender) {
+  // @ts-expect-error - Accessing private field
+  return sender.buffer.position;
+}
diff --git a/test/sender.config.test.ts b/test/sender.config.test.ts
new file mode 100644
index 0000000..8b7d4d1
--- /dev/null
+++ b/test/sender.config.test.ts
@@ -0,0 +1,444 @@
+// @ts-check
+import { describe, it, expect } from "vitest";
+
+import { Sender } from "../src";
+import { DEFAULT_BUFFER_SIZE, DEFAULT_MAX_BUFFER_SIZE } from "../src/buffer";
+import { log } from "../src/logging";
+
+describe("Sender configuration options suite", function () {
+  it("creates a sender from a configuration string", async function () {
+    await Sender.fromConfig("tcps::addr=hostname;").close();
+  });
+
+  it("creates a sender from a configuration string picked up from env", async function () {
+    process.env.QDB_CLIENT_CONF = "https::addr=hostname;";
+    await Sender.fromEnv().close();
+  });
+
+  it("throws exception if the username or the token is missing when TCP transport is used", async function () {
+    await expect(
+      async () =>
+        await Sender.fromConfig("tcp::addr=hostname;username=bobo;").close(),
+    ).rejects.toThrow(
+      "TCP transport requires a username and a private key for authentication, please, specify the 'username' and 'token' config options",
+    );
+
+    await expect(
+      async () =>
+        await Sender.fromConfig("tcp::addr=hostname;token=bobo_token;").close(),
+    ).rejects.toThrow(
+      "TCP transport requires a username and a private key for authentication, please, specify the 'username' and 'token' config options",
+    );
+  });
+
+  it("throws exception if tls_roots or tls_roots_password is used", async function () {
+    await expect(
+      async () =>
+        await Sender.fromConfig(
+          "tcps::addr=hostname;username=bobo;tls_roots=bla;",
+        ).close(),
+    ).rejects.toThrow(
+      "'tls_roots' and 'tls_roots_password' options are not supported, please, use the 'tls_ca' option or the NODE_EXTRA_CA_CERTS environment variable instead",
+    );
+
+    await expect(
+      async () =>
+        await Sender.fromConfig(
+          "tcps::addr=hostname;token=bobo_token;tls_roots_password=bla;",
+        ).close(),
+    ).rejects.toThrow(
+      "'tls_roots' and 'tls_roots_password' options are not supported, please, use the 'tls_ca' option or the NODE_EXTRA_CA_CERTS environment variable instead",
+    );
+  });
+
+  it("throws exception if connect() is called when http transport is used", async function () {
+    let sender: Sender;
+    await expect(async () => {
+      sender = Sender.fromConfig("http::addr=hostname");
+      await sender.connect();
+    }).rejects.toThrow("'connect()' is not required for HTTP transport");
+    await sender.close();
+  });
+});
+
+describe("Sender options test suite", function () {
+  it("fails if no options defined", async function () {
+    await expect(
+      async () =>
+        // @ts-expect-error - Testing invalid options
+        await new Sender().close(),
+    ).rejects.toThrow("The 'protocol' option is mandatory");
+  });
+
+  it("fails if options are null", async function () {
+    await expect(async () => await new Sender(null).close()).rejects.toThrow(
+      "The 'protocol' option is mandatory",
+    );
+  });
+
+  it("fails if options are undefined", async function () {
+    await expect(
+      async () => await new Sender(undefined).close(),
+    ).rejects.toThrow("The 'protocol' option is mandatory");
+  });
+
+  it("fails if options are empty", async function () {
+    await expect(
+      async () =>
+        // @ts-expect-error - Testing invalid options
+        await new Sender({}).close(),
+    ).rejects.toThrow("The 'protocol' option is mandatory");
+  });
+
+  it("fails if protocol option is missing", async function () {
+    await expect(
+      async () =>
+        // @ts-expect-error - Testing invalid options
+        await new Sender({ host: "host" }).close(),
+    ).rejects.toThrow("The 'protocol' option is mandatory");
+  });
+
+  it("fails if protocol option is invalid", async function () {
+    await expect(
+      async () =>
+        await new Sender({ protocol: "abcd", host: "hostname" }).close(),
+    ).rejects.toThrow("Invalid protocol: 'abcd'");
+  });
+
+  it("sets default buffer size if init_buf_size is not set", async function () {
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+    });
+    expect(bufferSize(sender)).toBe(DEFAULT_BUFFER_SIZE);
+    await sender.close();
+  });
+
+  it("sets the requested buffer size if init_buf_size is set", async function () {
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+      init_buf_size: 1024,
+    });
+    expect(bufferSize(sender)).toBe(1024);
+    await sender.close();
+  });
+
+  it("sets default buffer size if init_buf_size is set to null", async function () {
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+      init_buf_size: null,
+    });
+    expect(bufferSize(sender)).toBe(DEFAULT_BUFFER_SIZE);
+    await sender.close();
+  });
+
+  it("sets default buffer size if init_buf_size is set to undefined", async function () {
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+      init_buf_size: undefined,
+    });
+    expect(bufferSize(sender)).toBe(DEFAULT_BUFFER_SIZE);
+    await sender.close();
+  });
+
+  it("sets default buffer size if init_buf_size is not a number", async function () {
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+      // @ts-expect-error - Testing invalid options
+      init_buf_size: "1024",
+    });
+    expect(bufferSize(sender)).toBe(DEFAULT_BUFFER_SIZE);
+    await sender.close();
+  });
+
+  it("sets the requested buffer size if 'bufferSize' is set, but warns that it is deprecated", async function () {
+    const log = (
+      level: "error" | "warn" | "info" | "debug",
+      message: string | Error,
+    ) => {
+      if (level !== "debug") {
+        expect(level).toBe("warn");
+        expect(message).toMatch(
+          "Option 'bufferSize' is not supported anymore, please, replace it with 'init_buf_size'",
+        );
+      }
+    };
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+      // @ts-expect-error - Testing deprecated option
+      bufferSize: 2048,
+      log: log,
+    });
+    expect(bufferSize(sender)).toBe(2048);
+    await sender.close();
+  });
+
+  it("warns about deprecated option 'copy_buffer'", async function () {
+    const log = (
+      level: "error" | "warn" | "info" | "debug",
+      message: string,
+    ) => {
+      if (level !== "debug") {
+        expect(level).toBe("warn");
+        expect(message).toMatch(
+          "Option 'copy_buffer' is not supported anymore, please, remove it",
+        );
+      }
+    };
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+      // @ts-expect-error - Testing deprecated option
+      copy_buffer: false,
+      log: log,
+    });
+    await sender.close();
+  });
+
+  it("warns about deprecated option 'copyBuffer'", async function () {
+    const log = (
+      level: "error" | "warn" | "info" | "debug",
+      message: string,
+    ) => {
+      if (level !== "debug") {
+        expect(level).toBe("warn");
+        expect(message).toMatch(
+          "Option 'copyBuffer' is not supported anymore, please, remove it",
+        );
+      }
+    };
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+      // @ts-expect-error - Testing deprecated option
+      copyBuffer: false,
+      log: log,
+    });
+    await sender.close();
+  });
+
+  it("sets default max buffer size if max_buf_size is not set", async function () {
+    const sender = new Sender({ protocol: "http", host: "host" });
+    expect(maxBufferSize(sender)).toBe(DEFAULT_MAX_BUFFER_SIZE);
+    await sender.close();
+  });
+
+  it("sets the requested max buffer size if max_buf_size is set", async function () {
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+      max_buf_size: 131072,
+    });
+    expect(maxBufferSize(sender)).toBe(131072);
+    await sender.close();
+  });
+
+  it("throws error if initial buffer size is greater than max_buf_size", async function () {
+    await expect(
+      async () =>
+        await new Sender({
+          protocol: "http",
+          host: "host",
+          max_buf_size: 8192,
+          init_buf_size: 16384,
+        }).close(),
+    ).rejects.toThrow(
+      "Max buffer size is 8192 bytes, requested buffer size: 16384",
+    );
+  });
+
+  it("sets default max buffer size if max_buf_size is set to null", async function () {
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+      max_buf_size: null,
+    });
+    expect(maxBufferSize(sender)).toBe(DEFAULT_MAX_BUFFER_SIZE);
+    await sender.close();
+  });
+
+  it("sets default max buffer size if max_buf_size is set to undefined", async function () {
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+      max_buf_size: undefined,
+    });
+    expect(maxBufferSize(sender)).toBe(DEFAULT_MAX_BUFFER_SIZE);
+    await sender.close();
+  });
+
+  it("sets default max buffer size if max_buf_size is not a number", async function () {
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+      // @ts-expect-error - Testing invalid value
+      max_buf_size: "1024",
+    });
+    expect(maxBufferSize(sender)).toBe(DEFAULT_MAX_BUFFER_SIZE);
+    await sender.close();
+  });
+
+  it("uses default logger if log function is not set", async function () {
+    const sender = new Sender({ protocol: "http", host: "host" });
+    expect(logger(sender)).toBe(log);
+    await sender.close();
+  });
+
+  it("uses the required log function if it is set", async function () {
+    const testFunc = () => {};
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+      log: testFunc,
+    });
+    expect(logger(sender)).toBe(testFunc);
+    await sender.close();
+  });
+
+  it("uses default logger if log is set to null", async function () {
+    const sender = new Sender({ protocol: "http", host: "host", log: null });
+    expect(logger(sender)).toBe(log);
+    await sender.close();
+  });
+
+  it("uses default logger if log is set to undefined", async function () {
+    const sender = new Sender({
+      protocol: "http",
+      host: "host",
+      log: undefined,
+    });
+    expect(logger(sender)).toBe(log);
+    await sender.close();
+  });
+
+  it("uses default logger if log is not a function", async function () {
+    // @ts-expect-error - Testing invalid options
+    const sender = new Sender({ protocol: "http", host: "host", log: "" });
+    expect(logger(sender)).toBe(log);
+    await sender.close();
+  });
+});
+
+describe("Sender auth config checks suite", function () {
+  it("requires a username for authentication", async function () {
+    await expect(
+      async () =>
+        await new Sender({
+          protocol: "tcp",
+          host: "host",
+          auth: {
+            token: "privateKey",
+          },
+        }).close(),
+    ).rejects.toThrow(
+      "Missing username, please, specify the 'keyId' property of the 'auth' config option. " +
+        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
+    );
+  });
+
+  it("requires a non-empty username", async function () {
+    await expect(
+      async () =>
+        await new Sender({
+          protocol: "tcp",
+          host: "host",
+          auth: {
+            keyId: "",
+            token: "privateKey",
+          },
+        }).close(),
+    ).rejects.toThrow(
+      "Missing username, please, specify the 'keyId' property of the 'auth' config option. " +
+        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
+    );
+  });
+
+  it("requires that the username is a string", async function () {
+    await expect(
+      async () =>
+        await new Sender({
+          protocol: "tcp",
+          host: "host",
+          auth: {
+            // @ts-expect-error - Testing invalid options
+            keyId: 23,
+            token: "privateKey",
+          },
+        }).close(),
+    ).rejects.toThrow(
+      "Please, specify the 'keyId' property of the 'auth' config option as a string. " +
+        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
+    );
+  });
+
+  it("requires a private key for authentication", async function () {
+    await expect(
+      async () =>
+        await new Sender({
+          protocol: "tcp",
+          host: "host",
+          auth: {
+            keyId: "username",
+          },
+        }).close(),
+    ).rejects.toThrow(
+      "Missing private key, please, specify the 'token' property of the 'auth' config option. " +
+        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
+    );
+  });
+
+  it("requires a non-empty private key", async function () {
+    await expect(
+      async () =>
+        await new Sender({
+          protocol: "tcp",
+          host: "host",
+          auth: {
+            keyId: "username",
+            token: "",
+          },
+        }).close(),
+    ).rejects.toThrow(
+      "Missing private key, please, specify the 'token' property of the 'auth' config option. " +
+        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
+    );
+  });
+
+  it("requires that the private key is a string", async function () {
+    await expect(
+      async () =>
+        await new Sender({
+          protocol: "tcp",
+          host: "host",
+          auth: {
+            keyId: "username",
+            // @ts-expect-error - Testing invalid options
+            token: true,
+          },
+        }).close(),
+    ).rejects.toThrow(
+      "Please, specify the 'token' property of the 'auth' config option as a string. " +
+        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
+    );
+  });
+});
+
+function bufferSize(sender: Sender) {
+  // @ts-expect-error - Accessing private field
+  return sender.buffer.bufferSize;
+}
+
+function maxBufferSize(sender: Sender) {
+  // @ts-expect-error - Accessing private field
+  return sender.buffer.maxBufferSize;
+}
+
+function logger(sender: Sender) {
+  // @ts-expect-error - Accessing private field
+  return sender.log;
+}
diff --git a/test/sender.integration.test.ts b/test/sender.integration.test.ts
new file mode 100644
index 0000000..eff352e
--- /dev/null
+++ b/test/sender.integration.test.ts
@@ -0,0 +1,410 @@
+// @ts-check
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { GenericContainer, StartedTestContainer } from "testcontainers";
+import http from "http";
+
+import { Sender } from "../src";
+
+const HTTP_OK = 200;
+
+const QUESTDB_HTTP_PORT = 9000;
+const QUESTDB_ILP_PORT = 9009;
+
+async function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describe("Sender tests with containerized QuestDB instance", () => {
+  let container: StartedTestContainer;
+
+  async function query(container: StartedTestContainer, query: string) {
+    const options: http.RequestOptions = {
+      hostname: container.getHost(),
+      port: container.getMappedPort(QUESTDB_HTTP_PORT),
+      path: `/exec?query=${encodeURIComponent(query)}`,
+      method: "GET",
+    };
+
+    return new Promise((resolve, reject) => {
+      const req = http.request(options, (response) => {
+        if (response.statusCode === HTTP_OK) {
+          const body: Uint8Array[] = [];
+          response
+            .on("data", (data: Uint8Array) => {
+              body.push(data);
+            })
+            .on("end", () => {
+              resolve(JSON.parse(Buffer.concat(body).toString()));
+            });
+        } else {
+          reject(
+            new Error(
+              `HTTP request failed, statusCode=${response.statusCode}, query=${query}`,
+            ),
+          );
+        }
+      });
+
+      req.on("error", (error) => reject(error));
+      req.end();
+    });
+  }
+
+  async function runSelect(
+    container: StartedTestContainer,
+    select: string,
+    expectedCount: number,
+    timeout = 60000,
+  ) {
+    const interval = 500;
+    const num = timeout / interval;
+    let selectResult: any;
+    for (let i = 0; i < num; i++) {
+      selectResult = await query(container, select);
+      if (selectResult && selectResult.count >= expectedCount) {
+        return selectResult;
+      }
+      await sleep(interval);
+    }
+    throw new Error(
+      `Timed out while waiting for ${expectedCount} rows, select='${select}'`,
+    );
+  }
+
+  async function waitForTable(
+    container: StartedTestContainer,
+    tableName: string,
+    timeout = 30000,
+  ) {
+    await runSelect(
+      container,
+      `tables() where table_name='${tableName}'`,
+      1,
+      timeout,
+    );
+  }
+
+  beforeAll(async () => {
+    container = await new GenericContainer("questdb/questdb:nightly")
+      .withExposedPorts(QUESTDB_HTTP_PORT, QUESTDB_ILP_PORT)
+      .start();
+
+    const stream = await container.logs();
+    stream
+      .on("data", (line: string) => console.log(line))
+      .on("err", (line: string) => console.error(line))
+      .on("end", () => console.log("Stream closed"));
+  }, 3000000);
+
+  afterAll(async () => {
+    await container.stop();
+  });
+
+  it("can ingest data via TCP and run queries", async () => {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: container.getHost(),
+      port: container.getMappedPort(QUESTDB_ILP_PORT),
+    });
+    await sender.connect();
+
+    const tableName = "test_tcp";
+    const schema = [
+      { name: "location", type: "SYMBOL" },
+      { name: "temperature", type: "DOUBLE" },
+      { name: "timestamp", type: "TIMESTAMP" },
+    ];
+
+    // ingest via client
+    await sender
+      .table(tableName)
+      .symbol("location", "us")
+      .floatColumn("temperature", 17.1)
+      .at(1658484765000000000n, "ns");
+    await sender.flush();
+
+    // wait for the table
+    await waitForTable(container, tableName);
+
+    // query table
+    const select1Result = await runSelect(container, tableName, 1);
+    expect(select1Result.query).toBe(tableName);
+    expect(select1Result.count).toBe(1);
+    expect(select1Result.columns).toStrictEqual(schema);
+    expect(select1Result.dataset).toStrictEqual([
+      ["us", 17.1, "2022-07-22T10:12:45.000000Z"],
+    ]);
+
+    // ingest via client, add new column
+    await sender
+      .table(tableName)
+      .symbol("location", "us")
+      .floatColumn("temperature", 17.3)
+      .at(1658484765000666000n, "ns");
+    await sender
+      .table(tableName)
+      .symbol("location", "emea")
+      .floatColumn("temperature", 17.4)
+      .at(1658484765000999000n, "ns");
+    await sender
+      .table(tableName)
+      .symbol("location", "emea")
+      .symbol("city", "london")
+      .floatColumn("temperature", 18.8)
+      .at(1658484765001234000n, "ns");
+    await sender.flush();
+
+    // query table
+    const select2Result = await runSelect(container, tableName, 4);
+    expect(select2Result.query).toBe(tableName);
+    expect(select2Result.count).toBe(4);
+    expect(select2Result.columns).toStrictEqual([
+      { name: "location", type: "SYMBOL" },
+      { name: "temperature", type: "DOUBLE" },
+      { name: "timestamp", type: "TIMESTAMP" },
+      { name: "city", type: "SYMBOL" },
+    ]);
+    expect(select2Result.dataset).toStrictEqual([
+      ["us", 17.1, "2022-07-22T10:12:45.000000Z", null],
+      ["us", 17.3, "2022-07-22T10:12:45.000666Z", null],
+      ["emea", 17.4, "2022-07-22T10:12:45.000999Z", null],
+      ["emea", 18.8, "2022-07-22T10:12:45.001234Z", "london"],
+    ]);
+
+    await sender.close();
+  });
+
+  it("can ingest data via HTTP with auto flush rows", async () => {
+    const tableName = "test_http_rows";
+    const schema = [
+      { name: "location", type: "SYMBOL" },
+      { name: "temperature", type: "DOUBLE" },
+      { name: "timestamp", type: "TIMESTAMP" },
+    ];
+
+    const sender = Sender.fromConfig(
+      `http::addr=${container.getHost()}:${container.getMappedPort(QUESTDB_HTTP_PORT)};auto_flush_interval=0;auto_flush_rows=1`,
+    );
+
+    // ingest via client
+    await sender
+      .table(tableName)
+      .symbol("location", "us")
+      .floatColumn("temperature", 17.1)
+      .at(1658484765000000000n, "ns");
+
+    // wait for the table
+    await waitForTable(container, tableName);
+
+    // query table
+    const select1Result = await runSelect(container, tableName, 1);
+    expect(select1Result.query).toBe(tableName);
+    expect(select1Result.count).toBe(1);
+    expect(select1Result.columns).toStrictEqual(schema);
+    expect(select1Result.dataset).toStrictEqual([
+      ["us", 17.1, "2022-07-22T10:12:45.000000Z"],
+    ]);
+
+    // ingest via client, add new column
+    await sender
+      .table(tableName)
+      .symbol("location", "us")
+      .floatColumn("temperature", 17.36)
+      .at(1658484765000666000n, "ns");
+    await sender
+      .table(tableName)
+      .symbol("location", "emea")
+      .floatColumn("temperature", 17.41)
+      .at(1658484765000999000n, "ns");
+    await sender
+      .table(tableName)
+      .symbol("location", "emea")
+      .symbol("city", "london")
+      .floatColumn("temperature", 18.81)
+      .at(1658484765001234000n, "ns");
+
+    // query table
+    const select2Result = await runSelect(container, tableName, 4);
+    expect(select2Result.query).toBe(tableName);
+    expect(select2Result.count).toBe(4);
+    expect(select2Result.columns).toStrictEqual([
+      { name: "location", type: "SYMBOL" },
+      { name: "temperature", type: "DOUBLE" },
+      { name: "timestamp", type: "TIMESTAMP" },
+      { name: "city", type: "SYMBOL" },
+    ]);
+    expect(select2Result.dataset).toStrictEqual([
+      ["us", 17.1, "2022-07-22T10:12:45.000000Z", null],
+      ["us", 17.36, "2022-07-22T10:12:45.000666Z", null],
+      ["emea", 17.41, "2022-07-22T10:12:45.000999Z", null],
+      ["emea", 18.81, "2022-07-22T10:12:45.001234Z", "london"],
+    ]);
+
+    await sender.close();
+  });
+
+  it("can ingest data via HTTP with auto flush interval", async () => {
+    const tableName = "test_http_interval";
+    const schema = [
+      { name: "location", type: "SYMBOL" },
+      { name: "temperature", type: "DOUBLE" },
+      { name: "timestamp", type: "TIMESTAMP" },
+    ];
+
+    const sender = Sender.fromConfig(
+      `http::addr=${container.getHost()}:${container.getMappedPort(QUESTDB_HTTP_PORT)};auto_flush_interval=1;auto_flush_rows=0`,
+    );
+
+    // wait longer than the set auto flush interval to make sure there is a flush
+    await sleep(10);
+
+    // ingest via client
+    await sender
+      .table(tableName)
+      .symbol("location", "us")
+      .floatColumn("temperature", 17.1)
+      .at(1658484765000000000n, "ns");
+
+    // wait for the table
+    await waitForTable(container, tableName);
+
+    // query table
+    const select1Result = await runSelect(container, tableName, 1);
+    expect(select1Result.query).toBe(tableName);
+    expect(select1Result.count).toBe(1);
+    expect(select1Result.columns).toStrictEqual(schema);
+    expect(select1Result.dataset).toStrictEqual([
+      ["us", 17.1, "2022-07-22T10:12:45.000000Z"],
+    ]);
+
+    // ingest via client, add new column
+    await sleep(10);
+    await sender
+      .table(tableName)
+      .symbol("location", "us")
+      .floatColumn("temperature", 17.36)
+      .at(1658484765000666000n, "ns");
+    await sleep(10);
+    await sender
+      .table(tableName)
+      .symbol("location", "emea")
+      .floatColumn("temperature", 17.41)
+      .at(1658484765000999000n, "ns");
+    await sleep(10);
+    await sender
+      .table(tableName)
+      .symbol("location", "emea")
+      .symbol("city", "london")
+      .floatColumn("temperature", 18.81)
+      .at(1658484765001234000n, "ns");
+
+    // query table
+    const select2Result = await runSelect(container, tableName, 4);
+    expect(select2Result.query).toBe(tableName);
+    expect(select2Result.count).toBe(4);
+    expect(select2Result.columns).toStrictEqual([
+      { name: "location", type: "SYMBOL" },
+      { name: "temperature", type: "DOUBLE" },
+      { name: "timestamp", type: "TIMESTAMP" },
+      { name: "city", type: "SYMBOL" },
+    ]);
+    expect(select2Result.dataset).toStrictEqual([
+      ["us", 17.1, "2022-07-22T10:12:45.000000Z", null],
+      ["us", 17.36, "2022-07-22T10:12:45.000666Z", null],
+      ["emea", 17.41, "2022-07-22T10:12:45.000999Z", null],
+      ["emea", 18.81, "2022-07-22T10:12:45.001234Z", "london"],
+    ]);
+
+    await sender.close();
+  });
+
+  it("does not duplicate rows if await is missing when calling flush", async () => {
+    const sender = new Sender({
+      protocol: "tcp",
+      host: container.getHost(),
+      port: container.getMappedPort(QUESTDB_ILP_PORT),
+    });
+    await sender.connect();
+
+    const tableName = "test2";
+    const schema = [
+      { name: "location", type: "SYMBOL" },
+      { name: "temperature", type: "DOUBLE" },
+      { name: "timestamp", type: "TIMESTAMP" },
+    ];
+
+    // ingest via client
+    const numOfRows = 100;
+    for (let i = 0; i < numOfRows; i++) {
+      const p1 = sender
+        .table(tableName)
+        .symbol("location", "us")
+        .floatColumn("temperature", i)
+        .at(1658484765000000000n, "ns");
+      const p2 = sender.flush();
+      // IMPORTANT: missing 'await' for p1 and p2 is intentional!
+      expect(p1).toBeTruthy();
+      expect(p2).toBeTruthy();
+    }
+
+    // wait for the table
+    await waitForTable(container, tableName);
+
+    // query table
+    const selectQuery = `${tableName} order by temperature`;
+    const selectResult = await runSelect(container, selectQuery, numOfRows);
+    expect(selectResult.query).toBe(selectQuery);
+    expect(selectResult.count).toBe(numOfRows);
+    expect(selectResult.columns).toStrictEqual(schema);
+
+    const expectedData: (string | number)[][] = [];
+    for (let i = 0; i < numOfRows; i++) {
+      expectedData.push(["us", i, "2022-07-22T10:12:45.000000Z"]);
+    }
+    expect(selectResult.dataset).toStrictEqual(expectedData);
+
+    await sender.close();
+  });
+
+  it("ingests all data without loss under high load with auto-flush", async () => {
+    const sender = Sender.fromConfig(
+      `tcp::addr=${container.getHost()}:${container.getMappedPort(QUESTDB_ILP_PORT)};auto_flush_rows=5;auto_flush_interval=1`,
+    );
+    await sender.connect();
+
+    const tableName = "test_high_load_autoflush";
+    const numOfRows = 1000;
+    const promises: Promise<void>[] = [];
+
+    for (let i = 0; i < numOfRows; i++) {
+      // Not awaiting each .at() call individually to allow them to queue up
+      const p = sender
+        .table(tableName)
+        .intColumn("id", i)
+        .at(1658484765000000000n + BigInt(1000 * i), "ns"); // Unique timestamp for each row
+      promises.push(p);
+    }
+
+    // Wait for all .at() calls to complete their processing (including triggering auto-flushes)
+    await Promise.all(promises);
+
+    // Perform a final flush to ensure any data remaining in the buffer is sent.
+    // This will be queued correctly after any ongoing auto-flushes.
+    await sender.flush();
+
+    // Wait for the table
+    await waitForTable(container, tableName);
+
+    // Query table and verify count
+    const selectQuery = `SELECT id FROM ${tableName}`;
+    const selectResult = await runSelect(container, selectQuery, numOfRows);
+    expect(selectResult.count).toBe(numOfRows);
+
+    // Verify data integrity
+    for (let i = 0; i < numOfRows; i++) {
+      expect(selectResult.dataset[i][0]).toBe(i);
+    }
+
+    await sender.close();
+  }, 30000); // Increased test timeout for this specific test
+});
diff --git a/test/sender.test.ts b/test/sender.test.ts
deleted file mode 100644
index 57a60b5..0000000
--- a/test/sender.test.ts
+++ /dev/null
@@ -1,2176 +0,0 @@
-import { Sender } from "../src";
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { DEFAULT_BUFFER_SIZE, DEFAULT_MAX_BUFFER_SIZE } from "../src/sender";
-import { readFileSync } from "fs";
-import { MockProxy } from "./_utils_/mockproxy";
-import { MockHttp } from "./_utils_/mockhttp";
-import { GenericContainer } from "testcontainers";
-import http from "http";
-import { Agent } from "undici";
-import { SenderOptions } from "../src/options";
-import { fail } from "node:assert";
-import { log } from "../src/logging";
-
-const HTTP_OK = 200;
-
-const QUESTDB_HTTP_PORT = 9000;
-const QUESTDB_ILP_PORT = 9009;
-const MOCK_HTTP_PORT = 9099;
-const MOCK_HTTPS_PORT = 9098;
-const PROXY_PORT = 9088;
-const PROXY_HOST = "localhost";
-
-const proxyOptions = {
-  key: readFileSync("test/certs/server/server.key"),
-  cert: readFileSync("test/certs/server/server.crt"),
-  ca: readFileSync("test/certs/ca/ca.crt"),
-};
-
-const USER_NAME = "testapp";
-const PRIVATE_KEY = "9b9x5WhJywDEuo1KGQWSPNxtX-6X6R2BRCKhYMMY6n8";
-const AUTH: SenderOptions["auth"] = {
-  keyId: USER_NAME,
-  token: PRIVATE_KEY,
-};
-
-async function sleep(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-describe("Sender configuration options suite", function () {
-  it("creates a sender from a configuration string", async function () {
-    await Sender.fromConfig("tcps::addr=hostname;").close();
-  });
-
-  it("creates a sender from a configuration string picked up from env", async function () {
-    process.env.QDB_CLIENT_CONF = "https::addr=hostname;";
-    await Sender.fromEnv().close();
-  });
-
-  it("throws exception if the username or the token is missing when TCP transport is used", async function () {
-    try {
-      await Sender.fromConfig("tcp::addr=hostname;username=bobo;").close();
-      fail("Expected error is not thrown");
-    } catch (err) {
-      expect(err.message).toBe(
-        "TCP transport requires a username and a private key for authentication, please, specify the 'username' and 'token' config options",
-      );
-    }
-
-    try {
-      await Sender.fromConfig("tcp::addr=hostname;token=bobo_token;").close();
-      fail("Expected error is not thrown");
-    } catch (err) {
-      expect(err.message).toBe(
-        "TCP transport requires a username and a private key for authentication, please, specify the 'username' and 'token' config options",
-      );
-    }
-  });
-
-  it("throws exception if tls_roots or tls_roots_password is used", async function () {
-    try {
-      await Sender.fromConfig(
-        "tcps::addr=hostname;username=bobo;tls_roots=bla;",
-      ).close();
-      fail("Expected error is not thrown");
-    } catch (err) {
-      expect(err.message).toBe(
-        "'tls_roots' and 'tls_roots_password' options are not supported, please, use the 'tls_ca' option or the NODE_EXTRA_CA_CERTS environment variable instead",
-      );
-    }
-
-    try {
-      await Sender.fromConfig(
-        "tcps::addr=hostname;token=bobo_token;tls_roots_password=bla;",
-      ).close();
-      fail("Expected error is not thrown");
-    } catch (err) {
-      expect(err.message).toBe(
-        "'tls_roots' and 'tls_roots_password' options are not supported, please, use the 'tls_ca' option or the NODE_EXTRA_CA_CERTS environment variable instead",
-      );
-    }
-  });
-
-  it("throws exception if connect() is called when http transport is used", async function () {
-    let sender: Sender;
-    try {
-      sender = Sender.fromConfig("http::addr=hostname");
-      await sender.connect();
-      fail("Expected error is not thrown");
-    } catch (err) {
-      expect(err.message).toBe(
-        "'connect()' should be called only if the sender connects via TCP",
-      );
-    }
-    await sender.close();
-  });
-});
-
-describe("Sender options test suite", function () {
-  it("fails if no options defined", async function () {
-    try {
-      // @ts-expect-error - Testing invalid options
-      await new Sender().close();
-      fail("Expected error is not thrown");
-    } catch (err) {
-      expect(err.message).toBe("The 'protocol' option is mandatory");
-    }
-  });
-
-  it("fails if options are null", async function () {
-    try {
-      await new Sender(null).close();
-      fail("Expected error is not thrown");
-    } catch (err) {
-      expect(err.message).toBe("The 'protocol' option is mandatory");
-    }
-  });
-
-  it("fails if options are undefined", async function () {
-    try {
-      await new Sender(undefined).close();
-      fail("Expected error is not thrown");
-    } catch (err) {
-      expect(err.message).toBe("The 'protocol' option is mandatory");
-    }
-  });
-
-  it("fails if options are empty", async function () {
-    try {
-      // @ts-expect-error - Testing invalid options
-      await new Sender({}).close();
-      fail("Expected error is not thrown");
-    } catch (err) {
-      expect(err.message).toBe("The 'protocol' option is mandatory");
-    }
-  });
-
-  it("fails if protocol option is missing", async function () {
-    try {
-      // @ts-expect-error - Testing invalid options
-      await new Sender({ host: "host" }).close();
-      fail("Expected error is not thrown");
-    } catch (err) {
-      expect(err.message).toBe("The 'protocol' option is mandatory");
-    }
-  });
-
-  it("fails if protocol option is invalid", async function () {
-    try {
-      await new Sender({ protocol: "abcd" }).close();
-      fail("Expected error is not thrown");
-    } catch (err) {
-      expect(err.message).toBe("Invalid protocol: 'abcd'");
-    }
-  });
-
-  it("sets default buffer size if init_buf_size is not set", async function () {
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-    });
-    expect(sender.bufferSize).toBe(DEFAULT_BUFFER_SIZE);
-    await sender.close();
-  });
-
-  it("sets the requested buffer size if init_buf_size is set", async function () {
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(sender.bufferSize).toBe(1024);
-    await sender.close();
-  });
-
-  it("sets default buffer size if init_buf_size is set to null", async function () {
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-      init_buf_size: null,
-    });
-    expect(sender.bufferSize).toBe(DEFAULT_BUFFER_SIZE);
-    await sender.close();
-  });
-
-  it("sets default buffer size if init_buf_size is set to undefined", async function () {
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-      init_buf_size: undefined,
-    });
-    expect(sender.bufferSize).toBe(DEFAULT_BUFFER_SIZE);
-    await sender.close();
-  });
-
-  it("sets default buffer size if init_buf_size is not a number", async function () {
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-      // @ts-expect-error - Testing invalid options
-      init_buf_size: "1024",
-    });
-    expect(sender.bufferSize).toBe(DEFAULT_BUFFER_SIZE);
-    await sender.close();
-  });
-
-  it("sets the requested buffer size if 'bufferSize' is set, but warns that it is deprecated", async function () {
-    const log = (level: "error" | "warn" | "info" | "debug", message: string) => {
-      expect(level).toBe("warn");
-      expect(message).toMatch("Option 'bufferSize' is not supported anymore, please, replace it with 'init_buf_size'");
-    };
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-      // @ts-expect-error - Testing deprecated option
-      bufferSize: 2048,
-      log: log,
-    });
-    expect(sender.bufferSize).toBe(2048);
-    await sender.close();
-  });
-
-  it("warns about deprecated option 'copy_buffer'", async function () {
-    const log = (level: "error" | "warn" | "info" | "debug", message: string) => {
-      expect(level).toBe("warn");
-      expect(message).toMatch("Option 'copy_buffer' is not supported anymore, please, remove it");
-    };
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-      // @ts-expect-error - Testing deprecated option
-      copy_buffer: false,
-      log: log,
-    });
-    await sender.close();
-  });
-
-  it("warns about deprecated option 'copyBuffer'", async function () {
-    const log = (level: "error" | "warn" | "info" | "debug", message: string) => {
-      expect(level).toBe("warn");
-      expect(message).toMatch("Option 'copyBuffer' is not supported anymore, please, remove it");
-    };
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-      // @ts-expect-error - Testing deprecated option
-      copyBuffer: false,
-      log: log,
-    });
-    await sender.close();
-  });
-
-  it("sets default max buffer size if max_buf_size is not set", async function () {
-    const sender = new Sender({ protocol: "http", host: "host" });
-    expect(sender.maxBufferSize).toBe(DEFAULT_MAX_BUFFER_SIZE);
-    await sender.close();
-  });
-
-  it("sets the requested max buffer size if max_buf_size is set", async function () {
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-      max_buf_size: 131072,
-    });
-    expect(sender.maxBufferSize).toBe(131072);
-    await sender.close();
-  });
-
-  it("throws error if initial buffer size is greater than max_buf_size", async function () {
-    try {
-      await new Sender({
-        protocol: "http",
-        host: "host",
-        max_buf_size: 8192,
-        init_buf_size: 16384,
-      }).close();
-      fail('Expected error is not thrown');
-    } catch (err) {
-      expect(err.message).toBe(
-        "Max buffer size is 8192 bytes, requested buffer size: 16384",
-      );
-    }
-  });
-
-  it("sets default max buffer size if max_buf_size is set to null", async function () {
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-      max_buf_size: null,
-    });
-    expect(sender.maxBufferSize).toBe(DEFAULT_MAX_BUFFER_SIZE);
-    await sender.close();
-  });
-
-  it("sets default max buffer size if max_buf_size is set to undefined", async function () {
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-      max_buf_size: undefined,
-    });
-    expect(sender.maxBufferSize).toBe(DEFAULT_MAX_BUFFER_SIZE);
-    await sender.close();
-  });
-
-  it("sets default max buffer size if max_buf_size is not a number", async function () {
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-      // @ts-expect-error - Testing invalid vlaue
-      max_buf_size: "1024",
-    });
-    expect(sender.maxBufferSize).toBe(DEFAULT_MAX_BUFFER_SIZE);
-    await sender.close();
-  });
-
-  it("uses default logger if log function is not set", async function () {
-    const sender = new Sender({ protocol: "http", host: "host" });
-    expect(sender.log).toBe(log);
-    await sender.close();
-  });
-
-  it("uses the required log function if it is set", async function () {
-    const testFunc = () => { };
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-      log: testFunc,
-    });
-    expect(sender.log).toBe(testFunc);
-    await sender.close();
-  });
-
-  it("uses default logger if log is set to null", async function () {
-    const sender = new Sender({ protocol: "http", host: "host", log: null });
-    expect(sender.log).toBe(log);
-    await sender.close();
-  });
-
-  it("uses default logger if log is set to undefined", async function () {
-    const sender = new Sender({
-      protocol: "http",
-      host: "host",
-      log: undefined,
-    });
-    expect(sender.log).toBe(log);
-    await sender.close();
-  });
-
-  it("uses default logger if log is not a function", async function () {
-    // @ts-expect-error - Testing invalid options
-    const sender = new Sender({ protocol: "http", host: "host", log: "" });
-    expect(sender.log).toBe(log);
-    await sender.close();
-  });
-});
-
-describe("Sender auth config checks suite", function () {
-  it("requires a username for authentication", async function () {
-    try {
-      await new Sender({
-        protocol: "tcp",
-        host: "host",
-        auth: {
-          token: "privateKey",
-        },
-      }).close();
-      fail("it should not be able to create the sender");
-    } catch (err) {
-      expect(err.message).toBe(
-        "Missing username, please, specify the 'keyId' property of the 'auth' config option. " +
-        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
-      );
-    }
-  });
-
-  it("requires a non-empty username", async function () {
-    try {
-      await new Sender({
-        protocol: "tcp",
-        host: "host",
-        auth: {
-          keyId: "",
-          token: "privateKey",
-        },
-      }).close();
-      fail("it should not be able to create the sender");
-    } catch (err) {
-      expect(err.message).toBe(
-        "Missing username, please, specify the 'keyId' property of the 'auth' config option. " +
-        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
-      );
-    }
-  });
-
-  it("requires that the username is a string", async function () {
-    try {
-      await new Sender({
-        protocol: "tcp",
-        host: "host",
-        auth: {
-          // @ts-expect-error - Testing invalid options
-          keyId: 23,
-          token: "privateKey",
-        },
-      }).close();
-      fail("it should not be able to create the sender");
-    } catch (err) {
-      expect(err.message).toBe(
-        "Please, specify the 'keyId' property of the 'auth' config option as a string. " +
-        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
-      );
-    }
-  });
-
-  it("requires a private key for authentication", async function () {
-    try {
-      await new Sender({
-        protocol: "tcp",
-        host: "host",
-        auth: {
-          keyId: "username",
-        },
-      }).close();
-      fail("it should not be able to create the sender");
-    } catch (err) {
-      expect(err.message).toBe(
-        "Missing private key, please, specify the 'token' property of the 'auth' config option. " +
-        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
-      );
-    }
-  });
-
-  it("requires a non-empty private key", async function () {
-    try {
-      await new Sender({
-        protocol: "tcp",
-        host: "host",
-        auth: {
-          keyId: "username",
-          token: "",
-        },
-      }).close();
-      fail("it should not be able to create the sender");
-    } catch (err) {
-      expect(err.message).toBe(
-        "Missing private key, please, specify the 'token' property of the 'auth' config option. " +
-        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
-      );
-    }
-  });
-
-  it("requires that the private key is a string", async function () {
-    try {
-      await new Sender({
-        protocol: "tcp",
-        host: "host",
-        auth: {
-          keyId: "username",
-          // @ts-expect-error - Testing invalid options
-          token: true,
-        },
-      }).close();
-      fail("it should not be able to create the sender");
-    } catch (err) {
-      expect(err.message).toBe(
-        "Please, specify the 'token' property of the 'auth' config option as a string. " +
-        "For example: new Sender({protocol: 'tcp', host: 'host', auth: {keyId: 'username', token: 'private key'}})",
-      );
-    }
-  });
-});
-
-describe("Sender HTTP suite", function () {
-  async function sendData(sender: Sender) {
-    await sender
-      .table("test")
-      .symbol("location", "us")
-      .floatColumn("temperature", 17.1)
-      .at(1658484765000000000n, "ns");
-    await sender.flush();
-  }
-
-  const mockHttp = new MockHttp();
-  const mockHttps = new MockHttp();
-
-  beforeAll(async function () {
-    await mockHttp.start(MOCK_HTTP_PORT);
-    await mockHttps.start(MOCK_HTTPS_PORT, true, proxyOptions);
-  });
-
-  afterAll(async function () {
-    await mockHttp.stop();
-    await mockHttps.stop();
-  });
-
-  it("can ingest via HTTP", async function () {
-    mockHttp.reset();
-
-    const sender = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT}`,
-    );
-    await sendData(sender);
-    expect(mockHttp.numOfRequests).toBe(1);
-
-    await sender.close();
-  });
-
-  it("supports custom http agent", async function () {
-    mockHttp.reset();
-    const agent = new Agent({ pipelining: 3 });
-
-    const sender = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT}`,
-      { agent: agent },
-    );
-    await sendData(sender);
-    expect(mockHttp.numOfRequests).toBe(1);
-
-    const symbols = Object.getOwnPropertySymbols(sender.agent);
-    expect(sender.agent[symbols[6]]).toEqual({ pipelining: 3 });
-
-    await sender.close();
-    await agent.destroy();
-  });
-
-  it("can ingest via HTTPS", async function () {
-    mockHttps.reset();
-
-    const senderCertCheckFail = Sender.fromConfig(
-      `https::addr=${PROXY_HOST}:${MOCK_HTTPS_PORT}`,
-    );
-    await expect(sendData(senderCertCheckFail)).rejects.toThrowError(
-      "HTTP request failed, statusCode=unknown, error=self-signed certificate in certificate chain",
-    );
-    await senderCertCheckFail.close();
-
-    const senderWithCA = Sender.fromConfig(
-      `https::addr=${PROXY_HOST}:${MOCK_HTTPS_PORT};tls_ca=test/certs/ca/ca.crt`,
-    );
-    await sendData(senderWithCA);
-    expect(mockHttps.numOfRequests).toEqual(1);
-    await senderWithCA.close();
-
-    const senderVerifyOff = Sender.fromConfig(
-      `https::addr=${PROXY_HOST}:${MOCK_HTTPS_PORT};tls_verify=unsafe_off`,
-    );
-    await sendData(senderVerifyOff);
-    expect(mockHttps.numOfRequests).toEqual(2);
-    await senderVerifyOff.close();
-  }, 20000);
-
-  it("can ingest via HTTP with basic auth", async function () {
-    mockHttp.reset({ username: "user1", password: "pwd" });
-
-    const sender = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};username=user1;password=pwd`,
-    );
-    await sendData(sender);
-    expect(mockHttp.numOfRequests).toEqual(1);
-    await sender.close();
-
-    const senderFailPwd = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};username=user1;password=xyz`,
-    );
-    await expect(sendData(senderFailPwd)).rejects.toThrowError(
-      "HTTP request failed, statusCode=401",
-    );
-    await senderFailPwd.close();
-
-    const senderFailMissingPwd = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};username=user1z`,
-    );
-    await expect(sendData(senderFailMissingPwd)).rejects.toThrowError(
-      "HTTP request failed, statusCode=401",
-    );
-    await senderFailMissingPwd.close();
-
-    const senderFailUsername = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};username=xyz;password=pwd`,
-    );
-    await expect(sendData(senderFailUsername)).rejects.toThrowError(
-      "HTTP request failed, statusCode=401",
-    );
-    await senderFailUsername.close();
-
-    const senderFailMissingUsername = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};password=pwd`,
-    );
-    await expect(sendData(senderFailMissingUsername)).rejects.toThrowError(
-      "HTTP request failed, statusCode=401",
-    );
-    await senderFailMissingUsername.close();
-
-    const senderFailMissing = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT}`,
-    );
-    await expect(sendData(senderFailMissing)).rejects.toThrowError(
-      "HTTP request failed, statusCode=401",
-    );
-    await senderFailMissing.close();
-  });
-
-  it("can ingest via HTTP with token auth", async function () {
-    mockHttp.reset({ token: "abcdefghijkl123" });
-
-    const sender = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};token=abcdefghijkl123`,
-    );
-    await sendData(sender);
-    expect(mockHttp.numOfRequests).toBe(1);
-    await sender.close();
-
-    const senderFailToken = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};token=xyz`,
-    );
-    await expect(sendData(senderFailToken)).rejects.toThrowError(
-      "HTTP request failed, statusCode=401",
-    );
-    await senderFailToken.close();
-
-    const senderFailMissing = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT}`,
-    );
-    await expect(sendData(senderFailMissing)).rejects.toThrowError(
-      "HTTP request failed, statusCode=401",
-    );
-    await senderFailMissing.close();
-  });
-
-  it("can retry via HTTP", async function () {
-    mockHttp.reset({ responseCodes: [204, 500, 523, 504, 500] });
-
-    const sender = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT}`,
-    );
-    await sendData(sender);
-    expect(mockHttp.numOfRequests).toBe(5);
-
-    await sender.close();
-  });
-
-  it("fails when retry timeout expires", async function () {
-    // TODO: artificial delay (responseDelays) is the same as retry timeout,
-    //  This should result in the request failing on the second try.
-    //  However, with undici transport sometimes we reach the third request too.
-    //  Investigate why, probably because of pipelining?
-    mockHttp.reset({
-      responseCodes: [204, 500, 500],
-      responseDelays: [1000, 1000, 1000],
-    });
-
-    const sender = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};retry_timeout=1000`,
-    );
-    await expect(sendData(sender)).rejects.toThrowError(
-      "HTTP request failed, statusCode=500, error=Request failed"
-    );
-    await sender.close();
-  });
-
-  it("fails when HTTP request times out", async function () {
-    // artificial delay (responseDelays) is greater than request timeout, and retry is switched off
-    // should result in the request failing with timeout
-    mockHttp.reset({
-      responseCodes: [204],
-      responseDelays: [1000],
-    });
-
-    const sender = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};retry_timeout=0;request_timeout=100`,
-    );
-    await expect(sendData(sender)).rejects.toThrowError(
-      "HTTP request timeout, statusCode=undefined, error=Headers Timeout Error",
-    );
-    await sender.close();
-  });
-
-  it("succeeds on the third request after two timeouts", async function () {
-    mockHttp.reset({
-      responseCodes: [204, 504, 504],
-      responseDelays: [2000, 2000],
-    });
-
-    const sender = Sender.fromConfig(
-      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};retry_timeout=30000;request_timeout=1000`,
-    );
-    await sendData(sender);
-
-    await sender.close();
-  });
-
-  it("accepts custom http agent", async function () {
-    mockHttp.reset();
-    const agent = new Agent({ connect: { keepAlive: false } });
-
-    const num = 300;
-    const senders: Sender[] = [];
-    const promises: Promise<void>[] = [];
-    for (let i = 0; i < num; i++) {
-      const sender = Sender.fromConfig(
-        `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT}`,
-        { agent: agent },
-      );
-      senders.push(sender);
-      const promise = sendData(sender);
-      promises.push(promise);
-    }
-    await Promise.all(promises);
-    expect(mockHttp.numOfRequests).toBe(num);
-
-    for (const sender of senders) {
-      await sender.close();
-    }
-    await agent.destroy();
-  });
-});
-
-describe("Sender connection suite", function () {
-  async function createProxy(
-    auth = false,
-    tlsOptions?: Record<string, unknown>,
-  ) {
-    const mockConfig = { auth: auth, assertions: true };
-    const proxy = new MockProxy(mockConfig);
-    await proxy.start(PROXY_PORT, tlsOptions);
-    expect(proxy.mockConfig).toBe(mockConfig);
-    expect(proxy.dataSentToRemote).toStrictEqual([]);
-    return proxy;
-  }
-
-  async function createSender(auth: SenderOptions["auth"], secure = false) {
-    const sender = new Sender({
-      protocol: secure ? "tcps" : "tcp",
-      port: PROXY_PORT,
-      host: PROXY_HOST,
-      auth: auth,
-      tls_ca: "test/certs/ca/ca.crt",
-    });
-    const connected = await sender.connect();
-    expect(connected).toBe(true);
-    return sender;
-  }
-
-  async function sendData(sender: Sender) {
-    await sender
-      .table("test")
-      .symbol("location", "us")
-      .floatColumn("temperature", 17.1)
-      .at(1658484765000000000n, "ns");
-    await sender.flush();
-  }
-
-  async function assertSentData(
-    proxy: MockProxy,
-    authenticated: boolean,
-    expected: string,
-    timeout = 60000,
-  ) {
-    const interval = 100;
-    const num = timeout / interval;
-    let actual: string;
-    for (let i = 0; i < num; i++) {
-      const dataSentToRemote = proxy.getDataSentToRemote().join("").split("\n");
-      if (authenticated) {
-        dataSentToRemote.splice(1, 1);
-      }
-      actual = dataSentToRemote.join("\n");
-      if (actual === expected) {
-        return new Promise((resolve) => resolve(null));
-      }
-      await sleep(interval);
-    }
-    return new Promise((resolve) =>
-      resolve(`data assert failed [expected=${expected}, actual=${actual}]`),
-    );
-  }
-
-  it("can authenticate", async function () {
-    const proxy = await createProxy(true);
-    const sender = await createSender(AUTH);
-    await assertSentData(proxy, true, "testapp\n");
-    await sender.close();
-    await proxy.stop();
-  });
-
-  it("can authenticate with a different private key", async function () {
-    const proxy = await createProxy(true);
-    const sender = await createSender({
-      keyId: "user1",
-      token: "zhPiK3BkYMYJvRf5sqyrWNJwjDKHOWHnRbmQggUll6A",
-    });
-    await assertSentData(proxy, true, "user1\n");
-    await sender.close();
-    await proxy.stop();
-  });
-
-  it("is backwards compatible and still can authenticate with full JWK", async function () {
-    const JWK = {
-      x: "BtUXC_K3oAyGlsuPjTgkiwirMUJhuRQDfcUHeyoxFxU",
-      y: "R8SOup-rrNofB7wJagy4HrJhTVfrVKmj061lNRk3bF8",
-      kid: "user2",
-      kty: "EC",
-      d: "hsg6Zm4kSBlIEvKUWT3kif-2y2Wxw-iWaGrJxrPXQhs",
-      crv: "P-256",
-    };
-
-    const proxy = await createProxy(true);
-    const sender = new Sender({
-      protocol: "tcp",
-      port: PROXY_PORT,
-      host: PROXY_HOST,
-      jwk: JWK,
-    });
-    const connected = await sender.connect();
-    expect(connected).toBe(true);
-    await assertSentData(proxy, true, "user2\n");
-    await sender.close();
-    await proxy.stop();
-  });
-
-  it("can connect unauthenticated", async function () {
-    const proxy = await createProxy();
-    // @ts-expect-error invalid options
-    const sender = await createSender();
-    await assertSentData(proxy, false, "");
-    await sender.close();
-    await proxy.stop();
-  });
-
-  it("can authenticate and send data to server", async function () {
-    const proxy = await createProxy(true);
-    const sender = await createSender(AUTH);
-    await sendData(sender);
-    await assertSentData(
-      proxy,
-      true,
-      "testapp\ntest,location=us temperature=17.1 1658484765000000000\n",
-    );
-    await sender.close();
-    await proxy.stop();
-  });
-
-  it("can connect unauthenticated and send data to server", async function () {
-    const proxy = await createProxy();
-    // @ts-expect-error invalid options
-    const sender = await createSender();
-    await sendData(sender);
-    await assertSentData(
-      proxy,
-      false,
-      "test,location=us temperature=17.1 1658484765000000000\n",
-    );
-    await sender.close();
-    await proxy.stop();
-  });
-
-  it("can authenticate and send data to server via secure connection", async function () {
-    const proxy = await createProxy(true, proxyOptions);
-    const sender = await createSender(AUTH, true);
-    await sendData(sender);
-    await assertSentData(
-      proxy,
-      true,
-      "testapp\ntest,location=us temperature=17.1 1658484765000000000\n",
-    );
-    await sender.close();
-    await proxy.stop();
-  });
-
-  it("can connect unauthenticated and send data to server via secure connection", async function () {
-    const proxy = await createProxy(false, proxyOptions);
-    const sender = await createSender(null, true);
-    await sendData(sender);
-    await assertSentData(
-      proxy,
-      false,
-      "test,location=us temperature=17.1 1658484765000000000\n",
-    );
-    await sender.close();
-    await proxy.stop();
-  });
-
-  it("fails to connect without hostname and port", async function () {
-    const sender = new Sender({ protocol: "tcp" });
-    try {
-      await sender.connect();
-      fail("it should not be able to connect");
-    } catch (err) {
-      expect(err.message).toBe("Hostname is not set");
-    }
-    await sender.close();
-  });
-
-  it("fails to send data if not connected", async function () {
-    const sender = new Sender({ protocol: "tcp", host: "localhost" });
-    try {
-      await sender.table("test").symbol("location", "us").atNow();
-      await sender.flush();
-      fail("it should not be able to send data");
-    } catch (err) {
-      expect(err.message).toBe("TCP send failed, error=Sender is not connected");
-    }
-    await sender.close();
-  });
-
-  it("guards against multiple connect calls", async function () {
-    const proxy = await createProxy(true, proxyOptions);
-    const sender = await createSender(AUTH, true);
-    try {
-      await sender.connect();
-      fail("it should not be able to connect again");
-    } catch (err) {
-      expect(err.message).toBe("Sender connected already");
-    }
-    await sender.close();
-    await proxy.stop();
-  });
-
-  it("guards against concurrent connect calls", async function () {
-    const proxy = await createProxy(true, proxyOptions);
-    const sender = new Sender({
-      protocol: "tcps",
-      port: PROXY_PORT,
-      host: PROXY_HOST,
-      auth: AUTH,
-      tls_ca: "test/certs/ca/ca.crt",
-    });
-    try {
-      await Promise.all([sender.connect(), sender.connect()]);
-      fail("it should not be able to connect twice");
-    } catch (err) {
-      expect(err.message).toBe("Sender connected already");
-    }
-    await sender.close();
-    await proxy.stop();
-  });
-
-  it("can disable the server certificate check", async function () {
-    const proxy = await createProxy(true, proxyOptions);
-    const senderCertCheckFail = Sender.fromConfig(
-      `tcps::addr=${PROXY_HOST}:${PROXY_PORT}`,
-    );
-    try {
-      await senderCertCheckFail.connect();
-      fail("it should not be able to connect");
-    } catch (err) {
-      expect(err.message).toMatch(
-        /^self[ -]signed certificate in certificate chain$/,
-      );
-    }
-    await senderCertCheckFail.close();
-
-    const senderCertCheckOn = Sender.fromConfig(
-      `tcps::addr=${PROXY_HOST}:${PROXY_PORT};tls_ca=test/certs/ca/ca.crt`,
-    );
-    await senderCertCheckOn.connect();
-    await senderCertCheckOn.close();
-
-    const senderCertCheckOff = Sender.fromConfig(
-      `tcps::addr=${PROXY_HOST}:${PROXY_PORT};tls_verify=unsafe_off`,
-    );
-    await senderCertCheckOff.connect();
-    await senderCertCheckOff.close();
-    await proxy.stop();
-  });
-
-  it("can handle unfinished rows during flush()", async function () {
-    const proxy = await createProxy(true, proxyOptions);
-    const sender = await createSender(AUTH, true);
-    sender.table("test").symbol("location", "us");
-    const sent = await sender.flush();
-    expect(sent).toBe(false);
-    await assertSentData(proxy, true, "testapp\n");
-    await sender.close();
-    await proxy.stop();
-  });
-
-  it("supports custom logger", async function () {
-    const expectedMessages = [
-      "Successfully connected to localhost:9088",
-      /^Connection to .*1:9088 is closed$/,
-    ];
-    const log = (level: "error" | "warn" | "info" | "debug", message: string) => {
-      expect(level).toBe("info");
-      expect(message).toMatch(expectedMessages.shift());
-    };
-    const proxy = await createProxy();
-    const sender = new Sender({
-      protocol: "tcp",
-      port: PROXY_PORT,
-      host: PROXY_HOST,
-      log: log,
-    });
-    await sender.connect();
-    await sendData(sender);
-    await assertSentData(
-      proxy,
-      false,
-      "test,location=us temperature=17.1 1658484765000000000\n",
-    );
-    await sender.close();
-    await proxy.stop();
-  });
-});
-
-describe("Client interop test suite", function () {
-  it("runs client tests as per json test config", async function () {
-    const testCases = JSON.parse(
-      readFileSync(
-        "./questdb-client-test/ilp-client-interop-test.json",
-      ).toString(),
-    );
-
-    loopTestCase: for (const testCase of testCases) {
-      console.info(`test name: ${testCase.testName}`);
-      const sender = new Sender({
-        protocol: "tcp",
-        host: "host",
-        init_buf_size: 1024,
-      });
-      try {
-        sender.table(testCase.table);
-        for (const symbol of testCase.symbols) {
-          sender.symbol(symbol.name, symbol.value);
-        }
-        for (const column of testCase.columns) {
-          switch (column.type) {
-            case "STRING":
-              sender.stringColumn(column.name, column.value);
-              break;
-            case "LONG":
-              sender.intColumn(column.name, column.value);
-              break;
-            case "DOUBLE":
-              sender.floatColumn(column.name, column.value);
-              break;
-            case "BOOLEAN":
-              sender.booleanColumn(column.name, column.value);
-              break;
-            case "TIMESTAMP":
-              sender.timestampColumn(column.name, column.value);
-              break;
-            default:
-              fail("Unsupported column type");
-          }
-        }
-        await sender.atNow();
-      } catch (e) {
-        if (testCase.result.status !== "ERROR") {
-          fail("Did not expect error: " + e.message);
-        }
-        await sender.close();
-        continue;
-      }
-
-      const buffer = sender.toBufferView();
-      if (testCase.result.status === "SUCCESS") {
-        if (testCase.result.line) {
-          expect(buffer.toString()).toBe(testCase.result.line + "\n");
-        } else {
-          for (const line of testCase.result.anyLines) {
-            if (buffer.toString() === line + "\n") {
-              // test passed
-              await sender.close();
-              continue loopTestCase;
-            }
-          }
-          fail("Line is not matching any of the expected results: " + buffer.toString());
-        }
-      } else {
-        fail("Expected error missing, instead we have a line: " + buffer.toString());
-      }
-
-      await sender.close();
-    }
-  });
-});
-
-describe("Sender message builder test suite (anything not covered in client interop test suite)", function () {
-  it("throws on invalid timestamp unit", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    try {
-      await sender
-        .table("tableName")
-        .booleanColumn("boolCol", true)
-        // @ts-expect-error - Testing invalid options
-        .timestampColumn("timestampCol", 1658484765000000, "foobar")
-        .atNow();
-      fail("Expected error is not thrown");
-    } catch (err) {
-      expect(err.message).toBe("Unknown timestamp unit: foobar");
-    }
-    await sender.close();
-  });
-
-  it("supports json object", async function () {
-    const pages: Array<{
-      id: string;
-      gridId: string;
-    }>[] = [];
-    for (let i = 0; i < 4; i++) {
-      const pageProducts: Array<{
-        id: string;
-        gridId: string;
-      }> = [
-          {
-            id: "46022e96-076f-457f-b630-51b82b871618" + i,
-            gridId: "46022e96-076f-457f-b630-51b82b871618",
-          },
-          {
-            id: "55615358-4af1-4179-9153-faaa57d71e55",
-            gridId: "55615358-4af1-4179-9153-faaa57d71e55",
-          },
-          {
-            id: "365b9cdf-3d4e-4135-9cb0-f1a65601c840",
-            gridId: "365b9cdf-3d4e-4135-9cb0-f1a65601c840",
-          },
-          {
-            id: "0b67ddf2-8e69-4482-bf0c-bb987ee5c280",
-            gridId: "0b67ddf2-8e69-4482-bf0c-bb987ee5c280" + i,
-          },
-        ];
-      pages.push(pageProducts);
-    }
-
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 256,
-    });
-    for (const p of pages) {
-      await sender
-        .table("tableName")
-        .stringColumn("page_products", JSON.stringify(p || []))
-        .booleanColumn("boolCol", true)
-        .atNow();
-    }
-    expect(sender.toBufferView().toString()).toBe(
-      'tableName page_products="[{\\"id\\":\\"46022e96-076f-457f-b630-51b82b8716180\\",\\"gridId\\":\\"46022e96-076f-457f-b630-51b82b871618\\"},{\\"id\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\",\\"gridId\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\"},{\\"id\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\",\\"gridId\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\"},{\\"id\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c280\\",\\"gridId\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c2800\\"}]",boolCol=t\n' +
-      'tableName page_products="[{\\"id\\":\\"46022e96-076f-457f-b630-51b82b8716181\\",\\"gridId\\":\\"46022e96-076f-457f-b630-51b82b871618\\"},{\\"id\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\",\\"gridId\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\"},{\\"id\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\",\\"gridId\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\"},{\\"id\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c280\\",\\"gridId\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c2801\\"}]",boolCol=t\n' +
-      'tableName page_products="[{\\"id\\":\\"46022e96-076f-457f-b630-51b82b8716182\\",\\"gridId\\":\\"46022e96-076f-457f-b630-51b82b871618\\"},{\\"id\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\",\\"gridId\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\"},{\\"id\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\",\\"gridId\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\"},{\\"id\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c280\\",\\"gridId\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c2802\\"}]",boolCol=t\n' +
-      'tableName page_products="[{\\"id\\":\\"46022e96-076f-457f-b630-51b82b8716183\\",\\"gridId\\":\\"46022e96-076f-457f-b630-51b82b871618\\"},{\\"id\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\",\\"gridId\\":\\"55615358-4af1-4179-9153-faaa57d71e55\\"},{\\"id\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\",\\"gridId\\":\\"365b9cdf-3d4e-4135-9cb0-f1a65601c840\\"},{\\"id\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c280\\",\\"gridId\\":\\"0b67ddf2-8e69-4482-bf0c-bb987ee5c2803\\"}]",boolCol=t\n',
-    );
-    await sender.close();
-  });
-
-  it("supports timestamp field as number", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000000)
-      .atNow();
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t\n",
-    );
-    await sender.close();
-  });
-
-  it("supports timestamp field as ns number", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000000, "ns")
-      .atNow();
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000t\n",
-    );
-    await sender.close();
-  });
-
-  it("supports timestamp field as us number", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000000, "us")
-      .atNow();
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t\n",
-    );
-    await sender.close();
-  });
-
-  it("supports timestamp field as ms number", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000, "ms")
-      .atNow();
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t\n",
-    );
-    await sender.close();
-  });
-
-  it("supports timestamp field as BigInt", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000000n)
-      .atNow();
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t\n",
-    );
-    await sender.close();
-  });
-
-  it("supports timestamp field as ns BigInt", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000000000n, "ns")
-      .atNow();
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t\n",
-    );
-    await sender.close();
-  });
-
-  it("supports timestamp field as us BigInt", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000000n, "us")
-      .atNow();
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t\n",
-    );
-    await sender.close();
-  });
-
-  it("supports timestamp field as ms BigInt", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000n, "ms")
-      .atNow();
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t\n",
-    );
-    await sender.close();
-  });
-
-  it("throws on invalid designated timestamp unit", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    try {
-      await sender
-        .table("tableName")
-        .booleanColumn("boolCol", true)
-        .timestampColumn("timestampCol", 1658484765000000)
-        // @ts-expect-error - Testing invalid options
-        .at(1658484769000000, "foobar");
-    } catch (err) {
-      expect(err.message).toBe("Unknown timestamp unit: foobar");
-    }
-    await sender.close();
-  });
-
-  it("supports setting designated us timestamp as number from client", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000000)
-      .at(1658484769000000, "us");
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t 1658484769000000000\n",
-    );
-    await sender.close();
-  });
-
-  it("supports setting designated ms timestamp as number from client", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000000)
-      .at(1658484769000, "ms");
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t 1658484769000000000\n",
-    );
-    await sender.close();
-  });
-
-  it("supports setting designated timestamp as BigInt from client", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000000)
-      .at(1658484769000000n);
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t 1658484769000000000\n",
-    );
-    await sender.close();
-  });
-
-  it("supports setting designated ns timestamp as BigInt from client", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000000)
-      .at(1658484769000000123n, "ns");
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t 1658484769000000123\n",
-    );
-    await sender.close();
-  });
-
-  it("supports setting designated us timestamp as BigInt from client", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000000)
-      .at(1658484769000000n, "us");
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t 1658484769000000000\n",
-    );
-    await sender.close();
-  });
-
-  it("supports setting designated ms timestamp as BigInt from client", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000000)
-      .at(1658484769000n, "ms");
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t 1658484769000000000\n",
-    );
-    await sender.close();
-  });
-
-  it("throws exception if table name is not a string", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    // @ts-expect-error invalid options
-    expect(() => sender.table(23456)).toThrow(
-      "Table name must be a string, received number",
-    );
-    await sender.close();
-  });
-
-  it("throws exception if table name is too long", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(() =>
-      sender.table(
-        "123456789012345678901234567890123456789012345678901234567890" +
-        "12345678901234567890123456789012345678901234567890123456789012345678",
-      ),
-    ).toThrow("Table name is too long, max length is 127");
-    await sender.close();
-  });
-
-  it("throws exception if table name is set more times", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(() =>
-      sender.table("tableName").symbol("name", "value").table("newTableName"),
-    ).toThrow("Table name has already been set");
-    await sender.close();
-  });
-
-  it("throws exception if symbol name is not a string", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    // @ts-expect-error invalid options
-    expect(() => sender.table("tableName").symbol(12345.5656, "value")).toThrow(
-      "Symbol name must be a string, received number",
-    );
-    await sender.close();
-  });
-
-  it("throws exception if symbol name is empty string", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(() => sender.table("tableName").symbol("", "value")).toThrow(
-      "Empty string is not allowed as column name",
-    );
-    await sender.close();
-  });
-
-  it("throws exception if column name is not a string", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(() =>
-      // @ts-expect-error invalid options
-      sender.table("tableName").stringColumn(12345.5656, "value"),
-    ).toThrow("Column name must be a string, received number");
-    await sender.close();
-  });
-
-  it("throws exception if column name is empty string", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(() => sender.table("tableName").stringColumn("", "value")).toThrow(
-      "Empty string is not allowed as column name",
-    );
-    await sender.close();
-  });
-
-  it("throws exception if column name is too long", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(() =>
-      sender
-        .table("tableName")
-        .stringColumn(
-          "123456789012345678901234567890123456789012345678901234567890" +
-          "12345678901234567890123456789012345678901234567890123456789012345678",
-          "value",
-        ),
-    ).toThrow("Column name is too long, max length is 127");
-    await sender.close();
-  });
-
-  it("throws exception if column value is not the right type", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(() =>
-      // @ts-expect-error invalid options
-      sender.table("tableName").stringColumn("columnName", false),
-    ).toThrow("Column value must be of type string, received boolean");
-    await sender.close();
-  });
-
-  it("throws exception if adding column without setting table name", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(() => sender.floatColumn("name", 12.459)).toThrow(
-      "Column can be set only after table name is set",
-    );
-    await sender.close();
-  });
-
-  it("throws exception if adding symbol without setting table name", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(() => sender.symbol("name", "value")).toThrow(
-      "Symbol can be added only after table name is set and before any column added",
-    );
-    await sender.close();
-  });
-
-  it("throws exception if adding symbol after columns", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(() =>
-      sender
-        .table("tableName")
-        .stringColumn("name", "value")
-        .symbol("symbolName", "symbolValue"),
-    ).toThrow(
-      "Symbol can be added only after table name is set and before any column added",
-    );
-    await sender.close();
-  });
-
-  it("returns null if preparing an empty buffer for send", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(sender.toBufferView()).toBe(null);
-    expect(sender.toBufferNew()).toBe(null);
-    await sender.close();
-  });
-
-  it("leaves unfinished rows in the sender's buffer when preparing a copy of the buffer for send", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    sender.table("tableName").symbol("name", "value");
-    await sender.at(1234567890n, "ns");
-    sender.table("tableName").symbol("name", "value2");
-
-    // copy of the sender's buffer contains the finished row
-    expect(sender.toBufferNew(sender.endOfLastRow).toString()).toBe(
-      "tableName,name=value 1234567890\n",
-    );
-    // the sender's buffer is compacted, and contains only the unfinished row
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName,name=value2",
-    );
-    await sender.close();
-  });
-
-  it("throws exception if a float is passed as integer field", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(() =>
-      sender.table("tableName").intColumn("intField", 123.222),
-    ).toThrow("Value must be an integer, received 123.222");
-    await sender.close();
-  });
-
-  it("throws exception if a float is passed as timestamp field", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    expect(() =>
-      sender.table("tableName").timestampColumn("intField", 123.222),
-    ).toThrow("Value must be an integer or BigInt, received 123.222");
-    await sender.close();
-  });
-
-  it("throws exception if designated timestamp is not an integer or bigint", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    try {
-      await sender
-        .table("tableName")
-        .symbol("name", "value")
-        .at(23232322323.05);
-    } catch (e) {
-      expect(e.message).toEqual(
-        "Designated timestamp must be an integer or BigInt, received 23232322323.05",
-      );
-    }
-    await sender.close();
-  });
-
-  it("throws exception if designated timestamp is invalid", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    try {
-      // @ts-expect-error invalid options
-      await sender.table("tableName").symbol("name", "value").at("invalid_dts");
-    } catch (e) {
-      expect(e.message).toEqual(
-        "Designated timestamp must be an integer or BigInt, received invalid_dts",
-      );
-    }
-    await sender.close();
-  });
-
-  it("throws exception if designated timestamp is set without any fields added", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    try {
-      await sender.table("tableName").at(12345678n, "ns");
-    } catch (e) {
-      expect(e.message).toEqual(
-        "The row must have a symbol or column set before it is closed",
-      );
-    }
-    await sender.close();
-  });
-
-  it("extends the size of the buffer if data does not fit", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 8,
-    });
-    expect(sender.bufferSize).toBe(8);
-    expect(sender.position).toBe(0);
-    sender.table("tableName");
-    expect(sender.bufferSize).toBe(16);
-    expect(sender.position).toBe("tableName".length);
-    sender.intColumn("intField", 123);
-    expect(sender.bufferSize).toBe(32);
-    expect(sender.position).toBe("tableName intField=123i".length);
-    await sender.atNow();
-    expect(sender.bufferSize).toBe(32);
-    expect(sender.position).toBe("tableName intField=123i\n".length);
-    expect(sender.toBufferView().toString()).toBe("tableName intField=123i\n");
-
-    await sender
-      .table("table2")
-      .intColumn("intField", 125)
-      .stringColumn("strField", "test")
-      .atNow();
-    expect(sender.bufferSize).toBe(64);
-    expect(sender.position).toBe(
-      'tableName intField=123i\ntable2 intField=125i,strField="test"\n'.length,
-    );
-    expect(sender.toBufferView().toString()).toBe(
-      'tableName intField=123i\ntable2 intField=125i,strField="test"\n',
-    );
-    await sender.close();
-  });
-
-  it("throws exception if tries to extend the size of the buffer above max buffer size", async function () {
-    const sender = Sender.fromConfig(
-      "tcp::addr=host;init_buf_size=8;max_buf_size=48;",
-    );
-    expect(sender.bufferSize).toBe(8);
-    expect(sender.position).toBe(0);
-    sender.table("tableName");
-    expect(sender.bufferSize).toBe(16);
-    expect(sender.position).toBe("tableName".length);
-    sender.intColumn("intField", 123);
-    expect(sender.bufferSize).toBe(32);
-    expect(sender.position).toBe("tableName intField=123i".length);
-    await sender.atNow();
-    expect(sender.bufferSize).toBe(32);
-    expect(sender.position).toBe("tableName intField=123i\n".length);
-    expect(sender.toBufferView().toString()).toBe("tableName intField=123i\n");
-
-    try {
-      await sender
-        .table("table2")
-        .intColumn("intField", 125)
-        .stringColumn("strField", "test")
-        .atNow();
-    } catch (err) {
-      expect(err.message).toBe(
-        "Max buffer size is 48 bytes, requested buffer size: 64",
-      );
-    }
-    await sender.close();
-  });
-
-  it("is possible to clear the buffer by calling reset()", async function () {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: "host",
-      init_buf_size: 1024,
-    });
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", true)
-      .timestampColumn("timestampCol", 1658484765000000)
-      .atNow();
-    await sender
-      .table("tableName")
-      .booleanColumn("boolCol", false)
-      .timestampColumn("timestampCol", 1658484766000000)
-      .atNow();
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName boolCol=t,timestampCol=1658484765000000t\n" +
-      "tableName boolCol=f,timestampCol=1658484766000000t\n",
-    );
-
-    sender.reset();
-    await sender
-      .table("tableName")
-      .floatColumn("floatCol", 1234567890)
-      .timestampColumn("timestampCol", 1658484767000000)
-      .atNow();
-    expect(sender.toBufferView().toString()).toBe(
-      "tableName floatCol=1234567890,timestampCol=1658484767000000t\n",
-    );
-    await sender.close();
-  });
-});
-
-describe("Sender tests with containerized QuestDB instance", () => {
-  let container: any;
-
-  async function query(container: any, query: string) {
-    const options = {
-      hostname: container.getHost(),
-      port: container.getMappedPort(QUESTDB_HTTP_PORT),
-      path: `/exec?query=${encodeURIComponent(query)}`,
-      method: "GET",
-    };
-
-    return new Promise((resolve, reject) => {
-      const req = http.request(options, (response) => {
-        if (response.statusCode === HTTP_OK) {
-          const body: Uint8Array[] = [];
-          response
-            .on("data", (data: Uint8Array) => {
-              body.push(data);
-            })
-            .on("end", () => {
-              resolve(JSON.parse(Buffer.concat(body).toString()));
-            });
-        } else {
-          reject(
-            new Error(
-              `HTTP request failed, statusCode=${response.statusCode}, query=${query}`,
-            ),
-          );
-        }
-      });
-
-      req.on("error", (error) => {
-        reject(error);
-      });
-
-      req.end();
-    });
-  }
-
-  async function runSelect(container: any, select: string, expectedCount: number, timeout = 60000) {
-    const interval = 500;
-    const num = timeout / interval;
-    let selectResult: any;
-    for (let i = 0; i < num; i++) {
-      selectResult = await query(container, select);
-      if (selectResult && selectResult.count >= expectedCount) {
-        return selectResult;
-      }
-      await sleep(interval);
-    }
-    throw new Error(
-      `Timed out while waiting for ${expectedCount} rows, select='${select}'`,
-    );
-  }
-
-  async function waitForTable(container: any, tableName: string, timeout = 30000) {
-    await runSelect(container, `tables() where table_name='${tableName}'`, 1, timeout);
-  }
-
-  function getFieldsString(schema: any) {
-    let fields = "";
-    for (const element of schema) {
-      fields += `${element.name} ${element.type}, `;
-    }
-    return fields.substring(0, fields.length - 2);
-  }
-
-  beforeAll(async () => {
-    container = await new GenericContainer("questdb/questdb:nightly")
-      .withExposedPorts(QUESTDB_HTTP_PORT, QUESTDB_ILP_PORT)
-      .start();
-
-    const stream = await container.logs();
-    stream
-      .on("data", (line: string) => console.log(line))
-      .on("err", (line: string) => console.error(line))
-      .on("end", () => console.log("Stream closed"));
-  }, 3000000);
-
-  afterAll(async () => {
-    await container.stop();
-  });
-
-  it("can ingest data via TCP and run queries", async () => {
-    const sender = new Sender({
-      protocol: "tcp",
-      host: container.getHost(),
-      port: container.getMappedPort(QUESTDB_ILP_PORT),
-    });
-    await sender.connect();
-
-    const tableName = "test_tcp";
-    const schema = [
-      { name: "location", type: "SYMBOL" },
-      { name: "temperature", type: "DOUBLE" },
-      { name: "timestamp", type: "TIMESTAMP" },
-    ];
-
-    // ingest via client
-    await sender
-      .table(tableName)
-      .symbol("location", "us")
-      .floatColumn("temperature", 17.1)
-      .at(1658484765000000000n, "ns");
-    await sender.flush();
-
-    // wait for the table
-    await waitForTable(container, tableName)
-
-    // query table
-    const select1Result = await runSelect(container, tableName, 1);
-    expect(select1Result.query).toBe(tableName);
-    expect(select1Result.count).toBe(1);
-    expect(select1Result.columns).toStrictEqual(schema);
-    expect(select1Result.dataset).toStrictEqual([
-      ["us", 17.1, "2022-07-22T10:12:45.000000Z"],
-    ]);
-
-    // ingest via client, add new column
-    await sender
-      .table(tableName)
-      .symbol("location", "us")
-      .floatColumn("temperature", 17.3)
-      .at(1658484765000666000n, "ns");
-    await sender
-      .table(tableName)
-      .symbol("location", "emea")
-      .floatColumn("temperature", 17.4)
-      .at(1658484765000999000n, "ns");
-    await sender
-      .table(tableName)
-      .symbol("location", "emea")
-      .symbol("city", "london")
-      .floatColumn("temperature", 18.8)
-      .at(1658484765001234000n, "ns");
-    await sender.flush();
-
-    // query table
-    const select2Result = await runSelect(container, tableName, 4);
-    expect(select2Result.query).toBe(tableName);
-    expect(select2Result.count).toBe(4);
-    expect(select2Result.columns).toStrictEqual([
-      { name: "location", type: "SYMBOL" },
-      { name: "temperature", type: "DOUBLE" },
-      { name: "timestamp", type: "TIMESTAMP" },
-      { name: "city", type: "SYMBOL" },
-    ]);
-    expect(select2Result.dataset).toStrictEqual([
-      ["us", 17.1, "2022-07-22T10:12:45.000000Z", null],
-      ["us", 17.3, "2022-07-22T10:12:45.000666Z", null],
-      ["emea", 17.4, "2022-07-22T10:12:45.000999Z", null],
-      ["emea", 18.8, "2022-07-22T10:12:45.001234Z", "london"],
-    ]);
-
-    await sender.close();
-  });
-
-  it("can ingest data via HTTP with auto flush rows", async () => {
-    const tableName = "test_http_rows";
-    const schema = [
-      { name: "location", type: "SYMBOL" },
-      { name: "temperature", type: "DOUBLE" },
-      { name: "timestamp", type: "TIMESTAMP" },
-    ];
-
-    const sender = Sender.fromConfig(
-      `http::addr=${container.getHost()}:${container.getMappedPort(QUESTDB_HTTP_PORT)};auto_flush_interval=0;auto_flush_rows=1`,
-    );
-
-    // ingest via client
-    await sender
-      .table(tableName)
-      .symbol("location", "us")
-      .floatColumn("temperature", 17.1)
-      .at(1658484765000000000n, "ns");
-
-    // wait for the table
-    await waitForTable(container, tableName)
-
-    // query table
-    const select1Result = await runSelect(container, tableName, 1);
-    expect(select1Result.query).toBe(tableName);
-    expect(select1Result.count).toBe(1);
-    expect(select1Result.columns).toStrictEqual(schema);
-    expect(select1Result.dataset).toStrictEqual([
-      ["us", 17.1, "2022-07-22T10:12:45.000000Z"],
-    ]);
-
-    // ingest via client, add new column
-    await sender
-      .table(tableName)
-      .symbol("location", "us")
-      .floatColumn("temperature", 17.36)
-      .at(1658484765000666000n, "ns");
-    await sender
-      .table(tableName)
-      .symbol("location", "emea")
-      .floatColumn("temperature", 17.41)
-      .at(1658484765000999000n, "ns");
-    await sender
-      .table(tableName)
-      .symbol("location", "emea")
-      .symbol("city", "london")
-      .floatColumn("temperature", 18.81)
-      .at(1658484765001234000n, "ns");
-
-    // query table
-    const select2Result = await runSelect(container, tableName, 4);
-    expect(select2Result.query).toBe(tableName);
-    expect(select2Result.count).toBe(4);
-    expect(select2Result.columns).toStrictEqual([
-      { name: "location", type: "SYMBOL" },
-      { name: "temperature", type: "DOUBLE" },
-      { name: "timestamp", type: "TIMESTAMP" },
-      { name: "city", type: "SYMBOL" },
-    ]);
-    expect(select2Result.dataset).toStrictEqual([
-      ["us", 17.1, "2022-07-22T10:12:45.000000Z", null],
-      ["us", 17.36, "2022-07-22T10:12:45.000666Z", null],
-      ["emea", 17.41, "2022-07-22T10:12:45.000999Z", null],
-      ["emea", 18.81, "2022-07-22T10:12:45.001234Z", "london"],
-    ]);
-
-    await sender.close();
-  });
-
-  it("can ingest data via HTTP with auto flush interval", async () => {
-    const tableName = "test_http_interval";
-    const schema = [
-      { name: "location", type: "SYMBOL" },
-      { name: "temperature", type: "DOUBLE" },
-      { name: "timestamp", type: "TIMESTAMP" },
-    ];
-
-    const sender = Sender.fromConfig(
-      `http::addr=${container.getHost()}:${container.getMappedPort(QUESTDB_HTTP_PORT)};auto_flush_interval=1;auto_flush_rows=0`,
-    );
-
-    // wait longer than the set auto flush interval to make sure there is a flush
-    await sleep(10);
-
-    // ingest via client
-    await sender
-      .table(tableName)
-      .symbol("location", "us")
-      .floatColumn("temperature", 17.1)
-      .at(1658484765000000000n, "ns");
-
-    // wait for the table
-    await waitForTable(container, tableName)
-
-    // query table
-    const select1Result = await runSelect(container, tableName, 1);
-    expect(select1Result.query).toBe(tableName);
-    expect(select1Result.count).toBe(1);
-    expect(select1Result.columns).toStrictEqual(schema);
-    expect(select1Result.dataset).toStrictEqual([
-      ["us", 17.1, "2022-07-22T10:12:45.000000Z"],
-    ]);
-
-    // ingest via client, add new column
-    await sleep(10);
-    await sender
-      .table(tableName)
-      .symbol("location", "us")
-      .floatColumn("temperature", 17.36)
-      .at(1658484765000666000n, "ns");
-    await sleep(10);
-    await sender
-      .table(tableName)
-      .symbol("location", "emea")
-      .floatColumn("temperature", 17.41)
-      .at(1658484765000999000n, "ns");
-    await sleep(10);
-    await sender
-      .table(tableName)
-      .symbol("location", "emea")
-      .symbol("city", "london")
-      .floatColumn("temperature", 18.81)
-      .at(1658484765001234000n, "ns");
-
-    // query table
-    const select2Result = await runSelect(container, tableName, 4);
-    expect(select2Result.query).toBe(tableName);
-    expect(select2Result.count).toBe(4);
-    expect(select2Result.columns).toStrictEqual([
-      { name: "location", type: "SYMBOL" },
-      { name: "temperature", type: "DOUBLE" },
-      { name: "timestamp", type: "TIMESTAMP" },
-      { name: "city", type: "SYMBOL" },
-    ]);
-    expect(select2Result.dataset).toStrictEqual([
-      ["us", 17.1, "2022-07-22T10:12:45.000000Z", null],
-      ["us", 17.36, "2022-07-22T10:12:45.000666Z", null],
-      ["emea", 17.41, "2022-07-22T10:12:45.000999Z", null],
-      ["emea", 18.81, "2022-07-22T10:12:45.001234Z", "london"],
-    ]);
-
-    await sender.close();
-  });
-
-  it("does not duplicate rows if await is missing when calling flush", async () => {
-    // setting copyBuffer to make sure promises send data from their own local buffer
-    const sender = new Sender({
-      protocol: "tcp",
-      host: container.getHost(),
-      port: container.getMappedPort(QUESTDB_ILP_PORT),
-    });
-    await sender.connect();
-
-    const tableName = "test2";
-    const schema = [
-      { name: "location", type: "SYMBOL" },
-      { name: "temperature", type: "DOUBLE" },
-      { name: "timestamp", type: "TIMESTAMP" },
-    ];
-
-    // ingest via client
-    const numOfRows = 100;
-    for (let i = 0; i < numOfRows; i++) {
-      await sender
-        .table(tableName)
-        .symbol("location", "us")
-        .floatColumn("temperature", i)
-        .at(1658484765000000000n, "ns");
-      // missing await is intentional
-      await sender.flush();
-    }
-
-    // wait for the table
-    await waitForTable(container, tableName)
-
-    // query table
-    const selectQuery = `${tableName} order by temperature`;
-    const selectResult = await runSelect(container, selectQuery, numOfRows);
-    expect(selectResult.query).toBe(selectQuery);
-    expect(selectResult.count).toBe(numOfRows);
-    expect(selectResult.columns).toStrictEqual(schema);
-
-    const expectedData: (string | number)[][] = [];
-    for (let i = 0; i < numOfRows; i++) {
-      expectedData.push(["us", i, "2022-07-22T10:12:45.000000Z"]);
-    }
-    expect(selectResult.dataset).toStrictEqual(expectedData);
-
-    await sender.close();
-  });
-
-  it("ingests all data without loss under high load with auto-flush", async () => {
-    const sender = Sender.fromConfig(
-      `tcp::addr=${container.getHost()}:${container.getMappedPort(QUESTDB_ILP_PORT)};auto_flush_rows=5;auto_flush_interval=1`,
-    );
-    await sender.connect();
-
-    const tableName = "test_high_load_autoflush";
-    const numOfRows = 1000;
-    const promises: Promise<void>[] = [];
-
-    for (let i = 0; i < numOfRows; i++) {
-      // Not awaiting each .at() call individually to allow them to queue up
-      const p = sender
-        .table(tableName)
-        .intColumn("id", i)
-        .at(1658484765000000000n + BigInt(1000 * i), "ns"); // Unique timestamp for each row
-      promises.push(p);
-    }
-
-    // Wait for all .at() calls to complete their processing (including triggering auto-flushes)
-    await Promise.all(promises);
-
-    // Perform a final flush to ensure any data remaining in the buffer is sent.
-    // This will be queued correctly after any ongoing auto-flushes.
-    await sender.flush();
-
-    // Wait for the table
-    await waitForTable(container, tableName)
-
-    // Query table and verify count
-    const selectQuery = `SELECT id FROM ${tableName}`;
-    const selectResult = await runSelect(container, selectQuery, numOfRows);
-    expect(selectResult.count).toBe(numOfRows);
-
-    // Verify data integrity
-    for (let i = 0; i < numOfRows; i++) {
-      expect(selectResult.dataset[i][0]).toBe(i);
-    }
-
-    await sender.close();
-  }, 30000); // Increased test timeout for this specific test
-});
diff --git a/test/sender.transport.test.ts b/test/sender.transport.test.ts
new file mode 100644
index 0000000..7f3e20e
--- /dev/null
+++ b/test/sender.transport.test.ts
@@ -0,0 +1,615 @@
+// @ts-check
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { readFileSync } from "fs";
+import { Agent } from "undici";
+import http from "http";
+
+import { Sender } from "../src";
+import { SenderOptions } from "../src/options";
+import { UndiciTransport } from "../src/transport/http/undici";
+import { HttpTransport } from "../src/transport/http/stdlib";
+import { MockProxy } from "./util/mockproxy";
+import { MockHttp } from "./util/mockhttp";
+
+const MOCK_HTTP_PORT = 9099;
+const MOCK_HTTPS_PORT = 9098;
+const PROXY_PORT = 9088;
+const PROXY_HOST = "localhost";
+
+const proxyOptions = {
+  key: readFileSync("test/certs/server/server.key"),
+  cert: readFileSync("test/certs/server/server.crt"),
+  ca: readFileSync("test/certs/ca/ca.crt"),
+};
+
+const USER_NAME = "testapp";
+const PRIVATE_KEY = "9b9x5WhJywDEuo1KGQWSPNxtX-6X6R2BRCKhYMMY6n8";
+const AUTH: SenderOptions["auth"] = {
+  keyId: USER_NAME,
+  token: PRIVATE_KEY,
+};
+
+async function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describe("Sender HTTP suite", function () {
+  async function sendData(sender: Sender) {
+    await sender
+      .table("test")
+      .symbol("location", "us")
+      .floatColumn("temperature", 17.1)
+      .at(1658484765000000000n, "ns");
+    await sender.flush();
+  }
+
+  const mockHttp = new MockHttp();
+  const mockHttps = new MockHttp();
+
+  beforeAll(async function () {
+    await mockHttp.start(MOCK_HTTP_PORT);
+    await mockHttps.start(MOCK_HTTPS_PORT, true, proxyOptions);
+  });
+
+  afterAll(async function () {
+    await mockHttp.stop();
+    await mockHttps.stop();
+  });
+
+  it("can ingest via HTTP", async function () {
+    mockHttp.reset();
+
+    const sender = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT}`,
+    );
+    await sendData(sender);
+    expect(mockHttp.numOfRequests).toBe(1);
+
+    await sender.close();
+  });
+
+  it("can ingest via HTTPS", async function () {
+    mockHttps.reset();
+
+    const senderCertCheckFail = Sender.fromConfig(
+      `https::addr=${PROXY_HOST}:${MOCK_HTTPS_PORT}`,
+    );
+    await expect(sendData(senderCertCheckFail)).rejects.toThrowError(
+      "self-signed certificate in certificate chain",
+    );
+    await senderCertCheckFail.close();
+
+    const senderWithCA = Sender.fromConfig(
+      `https::addr=${PROXY_HOST}:${MOCK_HTTPS_PORT};tls_ca=test/certs/ca/ca.crt`,
+    );
+    await sendData(senderWithCA);
+    expect(mockHttps.numOfRequests).toEqual(1);
+    await senderWithCA.close();
+
+    const senderVerifyOff = Sender.fromConfig(
+      `https::addr=${PROXY_HOST}:${MOCK_HTTPS_PORT};tls_verify=unsafe_off`,
+    );
+    await sendData(senderVerifyOff);
+    expect(mockHttps.numOfRequests).toEqual(2);
+    await senderVerifyOff.close();
+  }, 20000);
+
+  it("can ingest via HTTP with basic auth", async function () {
+    mockHttp.reset({ username: "user1", password: "pwd" });
+
+    const sender = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};username=user1;password=pwd`,
+    );
+    await sendData(sender);
+    expect(mockHttp.numOfRequests).toEqual(1);
+    await sender.close();
+
+    const senderFailPwd = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};username=user1;password=xyz`,
+    );
+    await expect(sendData(senderFailPwd)).rejects.toThrowError(
+      "HTTP request failed, statusCode=401",
+    );
+    await senderFailPwd.close();
+
+    const senderFailMissingPwd = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};username=user1z`,
+    );
+    await expect(sendData(senderFailMissingPwd)).rejects.toThrowError(
+      "HTTP request failed, statusCode=401",
+    );
+    await senderFailMissingPwd.close();
+
+    const senderFailUsername = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};username=xyz;password=pwd`,
+    );
+    await expect(sendData(senderFailUsername)).rejects.toThrowError(
+      "HTTP request failed, statusCode=401",
+    );
+    await senderFailUsername.close();
+
+    const senderFailMissingUsername = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};password=pwd`,
+    );
+    await expect(sendData(senderFailMissingUsername)).rejects.toThrowError(
+      "HTTP request failed, statusCode=401",
+    );
+    await senderFailMissingUsername.close();
+
+    const senderFailMissing = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT}`,
+    );
+    await expect(sendData(senderFailMissing)).rejects.toThrowError(
+      "HTTP request failed, statusCode=401",
+    );
+    await senderFailMissing.close();
+  });
+
+  it("can ingest via HTTP with token auth", async function () {
+    mockHttp.reset({ token: "abcdefghijkl123" });
+
+    const sender = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};token=abcdefghijkl123`,
+    );
+    await sendData(sender);
+    expect(mockHttp.numOfRequests).toBe(1);
+    await sender.close();
+
+    const senderFailToken = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};token=xyz`,
+    );
+    await expect(sendData(senderFailToken)).rejects.toThrowError(
+      "HTTP request failed, statusCode=401",
+    );
+    await senderFailToken.close();
+
+    const senderFailMissing = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT}`,
+    );
+    await expect(sendData(senderFailMissing)).rejects.toThrowError(
+      "HTTP request failed, statusCode=401",
+    );
+    await senderFailMissing.close();
+  });
+
+  it("can retry via HTTP", async function () {
+    mockHttp.reset({ responseCodes: [204, 500, 523, 504, 500] });
+
+    const sender = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT}`,
+    );
+    await sendData(sender);
+    expect(mockHttp.numOfRequests).toBe(5);
+
+    await sender.close();
+  });
+
+  it("fails when retry timeout expires", async function () {
+    // artificial delay (responseDelays) is the same as retry timeout,
+    // this should result in the request failing on the second try.
+    mockHttp.reset({
+      responseCodes: [204, 500, 503],
+      responseDelays: [1000, 1000, 1000],
+    });
+
+    const sender = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};retry_timeout=1000`,
+    );
+    await expect(sendData(sender)).rejects.toThrowError(
+      "HTTP request timeout, no response from server in time",
+    );
+    await sender.close();
+  });
+
+  it("fails when HTTP request times out", async function () {
+    // artificial delay (responseDelays) is greater than request timeout, and retry is switched off
+    // should result in the request failing with timeout
+    mockHttp.reset({
+      responseCodes: [204],
+      responseDelays: [1000],
+    });
+
+    const sender = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};retry_timeout=0;request_timeout=100`,
+    );
+    await expect(sendData(sender)).rejects.toThrowError(
+      "HTTP request timeout, no response from server in time",
+    );
+    await sender.close();
+  });
+
+  it("succeeds on the third request after two timeouts", async function () {
+    mockHttp.reset({
+      responseCodes: [204, 504, 504],
+      responseDelays: [2000, 2000],
+    });
+
+    const sender = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};retry_timeout=600000;request_timeout=1000`,
+    );
+    await sendData(sender);
+
+    await sender.close();
+  });
+
+  it("multiple senders can use a single HTTP agent", async function () {
+    mockHttp.reset();
+    const agent = new Agent({ connect: { keepAlive: false } });
+
+    const num = 300;
+    const senders: Sender[] = [];
+    const promises: Promise<void>[] = [];
+    for (let i = 0; i < num; i++) {
+      const sender = Sender.fromConfig(
+        `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT}`,
+        { agent: agent },
+      );
+      senders.push(sender);
+      const promise = sendData(sender);
+      promises.push(promise);
+    }
+    await Promise.all(promises);
+    expect(mockHttp.numOfRequests).toBe(num);
+
+    for (const sender of senders) {
+      await sender.close();
+    }
+    await agent.destroy();
+  });
+
+  it("supports custom Undici HTTP agent", async function () {
+    mockHttp.reset();
+    const agent = new Agent({ pipelining: 3 });
+
+    const sender = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT}`,
+      { agent: agent },
+    );
+
+    await sendData(sender);
+    expect(mockHttp.numOfRequests).toBe(1);
+
+    // @ts-expect-error - Accessing private field
+    const senderAgent = (sender.transport as UndiciTransport).agent;
+    const symbols = Object.getOwnPropertySymbols(senderAgent);
+    expect(senderAgent[symbols[6]]).toEqual({ pipelining: 3 });
+
+    await sender.close();
+    await agent.destroy();
+  });
+
+  it("supports custom stdlib HTTP agent", async function () {
+    mockHttp.reset();
+    const agent = new http.Agent({ maxSockets: 128 });
+
+    const sender = Sender.fromConfig(
+      `http::addr=${PROXY_HOST}:${MOCK_HTTP_PORT};stdlib_http=on`,
+      { agent: agent },
+    );
+    await sendData(sender);
+    expect(mockHttp.numOfRequests).toBe(1);
+
+    // @ts-expect-error - Accessing private field
+    const senderAgent = (sender.transport as HttpTransport).agent;
+    expect(senderAgent.maxSockets).toBe(128);
+
+    await sender.close();
+    agent.destroy();
+  });
+});
+
+describe("Sender TCP suite", function () {
+  async function createProxy(
+    auth = false,
+    tlsOptions?: Record<string, unknown>,
+  ) {
+    const mockConfig = { auth: auth, assertions: true };
+    const proxy = new MockProxy(mockConfig);
+    await proxy.start(PROXY_PORT, tlsOptions);
+    expect(proxy.mockConfig).toBe(mockConfig);
+    expect(proxy.dataSentToRemote).toStrictEqual([]);
+    return proxy;
+  }
+
+  async function createSender(auth: SenderOptions["auth"], secure = false) {
+    const sender = new Sender({
+      protocol: secure ? "tcps" : "tcp",
+      port: PROXY_PORT,
+      host: PROXY_HOST,
+      auth: auth,
+      tls_ca: "test/certs/ca/ca.crt",
+    });
+    const connected = await sender.connect();
+    expect(connected).toBe(true);
+    return sender;
+  }
+
+  async function sendData(sender: Sender) {
+    await sender
+      .table("test")
+      .symbol("location", "us")
+      .floatColumn("temperature", 17.1)
+      .at(1658484765000000000n, "ns");
+    await sender.flush();
+  }
+
+  async function assertSentData(
+    proxy: MockProxy,
+    authenticated: boolean,
+    expected: string,
+    timeout = 60000,
+  ) {
+    const interval = 100;
+    const num = timeout / interval;
+    let actual: string;
+    for (let i = 0; i < num; i++) {
+      const dataSentToRemote = proxy.getDataSentToRemote().join("").split("\n");
+      if (authenticated) {
+        dataSentToRemote.splice(1, 1);
+      }
+      actual = dataSentToRemote.join("\n");
+      if (actual === expected) {
+        return new Promise((resolve) => resolve(null));
+      }
+      await sleep(interval);
+    }
+    return new Promise((resolve) =>
+      resolve(`data assert failed [expected=${expected}, actual=${actual}]`),
+    );
+  }
+
+  it("can authenticate", async function () {
+    const proxy = await createProxy(true);
+    const sender = await createSender(AUTH);
+    await assertSentData(proxy, true, "testapp\n");
+    await sender.close();
+    await proxy.stop();
+  });
+
+  it("can authenticate with a different private key", async function () {
+    const proxy = await createProxy(true);
+    const sender = await createSender({
+      keyId: "user1",
+      token: "zhPiK3BkYMYJvRf5sqyrWNJwjDKHOWHnRbmQggUll6A",
+    });
+    await assertSentData(proxy, true, "user1\n");
+    await sender.close();
+    await proxy.stop();
+  });
+
+  it("is backwards compatible and still can authenticate with full JWK", async function () {
+    const JWK = {
+      x: "BtUXC_K3oAyGlsuPjTgkiwirMUJhuRQDfcUHeyoxFxU",
+      y: "R8SOup-rrNofB7wJagy4HrJhTVfrVKmj061lNRk3bF8",
+      kid: "user2",
+      kty: "EC",
+      d: "hsg6Zm4kSBlIEvKUWT3kif-2y2Wxw-iWaGrJxrPXQhs",
+      crv: "P-256",
+    };
+
+    const proxy = await createProxy(true);
+    const sender = new Sender({
+      protocol: "tcp",
+      port: PROXY_PORT,
+      host: PROXY_HOST,
+      jwk: JWK,
+    });
+    const connected = await sender.connect();
+    expect(connected).toBe(true);
+    await assertSentData(proxy, true, "user2\n");
+    await sender.close();
+    await proxy.stop();
+  });
+
+  it("can connect unauthenticated", async function () {
+    const proxy = await createProxy();
+    // @ts-expect-error - Invalid options
+    const sender = await createSender();
+    await assertSentData(proxy, false, "");
+    await sender.close();
+    await proxy.stop();
+  });
+
+  it("can authenticate and send data to server", async function () {
+    const proxy = await createProxy(true);
+    const sender = await createSender(AUTH);
+    await sendData(sender);
+    await assertSentData(
+      proxy,
+      true,
+      "testapp\ntest,location=us temperature=17.1 1658484765000000000\n",
+    );
+    await sender.close();
+    await proxy.stop();
+  });
+
+  it("can connect unauthenticated and send data to server", async function () {
+    const proxy = await createProxy();
+    // @ts-expect-error - Invalid options
+    const sender = await createSender();
+    await sendData(sender);
+    await assertSentData(
+      proxy,
+      false,
+      "test,location=us temperature=17.1 1658484765000000000\n",
+    );
+    await sender.close();
+    await proxy.stop();
+  });
+
+  it("can authenticate and send data to server via secure connection", async function () {
+    const proxy = await createProxy(true, proxyOptions);
+    const sender = await createSender(AUTH, true);
+    await sendData(sender);
+    await assertSentData(
+      proxy,
+      true,
+      "testapp\ntest,location=us temperature=17.1 1658484765000000000\n",
+    );
+    await sender.close();
+    await proxy.stop();
+  });
+
+  it("can connect unauthenticated and send data to server via secure connection", async function () {
+    const proxy = await createProxy(false, proxyOptions);
+    const sender = await createSender(null, true);
+    await sendData(sender);
+    await assertSentData(
+      proxy,
+      false,
+      "test,location=us temperature=17.1 1658484765000000000\n",
+    );
+    await sender.close();
+    await proxy.stop();
+  });
+
+  it("fails to connect without hostname and port", async function () {
+    await expect(
+      async () => await new Sender({ protocol: "tcp" }).close(),
+    ).rejects.toThrow("The 'host' option is mandatory");
+  });
+
+  it("fails to send data if not connected", async function () {
+    const sender = new Sender({ protocol: "tcp", host: "localhost" });
+    await expect(async () => {
+      await sender.table("test").symbol("location", "us").atNow();
+      await sender.flush();
+    }).rejects.toThrow("TCP transport is not connected");
+    await sender.close();
+  });
+
+  it("guards against multiple connect calls", async function () {
+    const proxy = await createProxy(true, proxyOptions);
+    const sender = await createSender(AUTH, true);
+    await expect(async () => await sender.connect()).rejects.toThrow(
+      "Sender connected already",
+    );
+    await sender.close();
+    await proxy.stop();
+  });
+
+  it("guards against concurrent connect calls", async function () {
+    const proxy = await createProxy(true, proxyOptions);
+    const sender = new Sender({
+      protocol: "tcps",
+      port: PROXY_PORT,
+      host: PROXY_HOST,
+      auth: AUTH,
+      tls_ca: "test/certs/ca/ca.crt",
+    });
+    await expect(
+      async () => await Promise.all([sender.connect(), sender.connect()]),
+    ).rejects.toThrow("Sender connected already");
+    await sender.close();
+    await proxy.stop();
+  });
+
+  it("can disable the server certificate check", async function () {
+    const proxy = await createProxy(true, proxyOptions);
+    const senderCertCheckFail = Sender.fromConfig(
+      `tcps::addr=${PROXY_HOST}:${PROXY_PORT}`,
+    );
+    await expect(
+      async () => await senderCertCheckFail.connect(),
+    ).rejects.toThrow("self-signed certificate in certificate chain");
+    await senderCertCheckFail.close();
+
+    const senderCertCheckOn = Sender.fromConfig(
+      `tcps::addr=${PROXY_HOST}:${PROXY_PORT};tls_ca=test/certs/ca/ca.crt`,
+    );
+    await senderCertCheckOn.connect();
+    await senderCertCheckOn.close();
+
+    const senderCertCheckOff = Sender.fromConfig(
+      `tcps::addr=${PROXY_HOST}:${PROXY_PORT};tls_verify=unsafe_off`,
+    );
+    await senderCertCheckOff.connect();
+    await senderCertCheckOff.close();
+    await proxy.stop();
+  });
+
+  it("can handle unfinished rows during flush()", async function () {
+    const proxy = await createProxy(true, proxyOptions);
+    const sender = await createSender(AUTH, true);
+    sender.table("test").symbol("location", "us");
+    const sent = await sender.flush();
+    expect(sent).toBe(false);
+    await assertSentData(proxy, true, "testapp\n");
+    await sender.close();
+    await proxy.stop();
+  });
+
+  it("supports custom logger", async function () {
+    const expectedMessages = [
+      "Successfully connected to localhost:9088",
+      /^Connection to .*1:9088 is closed$/,
+    ];
+    const log = (
+      level: "error" | "warn" | "info" | "debug",
+      message: string,
+    ) => {
+      if (level !== "debug") {
+        expect(level).toBe("info");
+        expect(message).toMatch(expectedMessages.shift());
+      }
+    };
+    const proxy = await createProxy();
+    const sender = new Sender({
+      protocol: "tcp",
+      port: PROXY_PORT,
+      host: PROXY_HOST,
+      log: log,
+    });
+    await sender.connect();
+    await sendData(sender);
+    await assertSentData(
+      proxy,
+      false,
+      "test,location=us temperature=17.1 1658484765000000000\n",
+    );
+    await sender.close();
+    await proxy.stop();
+  });
+
+  it("warns if data is lost on close()", async function () {
+    // we expect a warning about non-flushed data at close()
+    const expectedMessages = [
+      "Successfully connected to localhost:9088",
+      "Buffer contains data which has not been flushed before closing the sender, and it will be lost [position=54]",
+      /^Connection to .*1:9088 is closed$/,
+    ];
+    const log = (
+      level: "error" | "warn" | "info" | "debug",
+      message: string,
+    ) => {
+      if (level !== "debug") {
+        expect(message).toMatch(expectedMessages.shift());
+      }
+    };
+    const proxy = await createProxy();
+    const sender = new Sender({
+      protocol: "tcp",
+      port: PROXY_PORT,
+      host: PROXY_HOST,
+      log: log,
+    });
+    await sender.connect();
+    await sendData(sender);
+
+    // add another line to the buffer without calling flush()
+    await sender
+      .table("test")
+      .symbol("location", "gb")
+      .floatColumn("temperature", 16.4)
+      .at(1658484775000000000n, "ns");
+
+    // assert that only the first line was sent
+    await assertSentData(
+      proxy,
+      false,
+      "test,location=us temperature=17.1 1658484765000000000\n",
+    );
+    await sender.close();
+    await proxy.stop();
+  });
+});
diff --git a/test/testapp.ts b/test/testapp.ts
index 9aedd9c..39f1267 100644
--- a/test/testapp.ts
+++ b/test/testapp.ts
@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 
-import { Proxy } from "./_utils_/proxy";
+import { Proxy } from "./util/proxy";
 import { Sender } from "../src";
 import { SenderOptions } from "../src/options";
 
@@ -8,13 +8,6 @@ const PROXY_PORT = 9099;
 const PORT = 9009;
 const HOST = "localhost";
 
-const USER_NAME = "testapp";
-const PRIVATE_KEY = "9b9x5WhJywDEuo1KGQWSPNxtX-6X6R2BRCKhYMMY6n8";
-const AUTH = {
-  kid: USER_NAME,
-  d: PRIVATE_KEY,
-};
-
 const senderOptions: SenderOptions = {
   protocol: "tcps",
   host: HOST,
diff --git a/test/util/mockhttp.ts b/test/util/mockhttp.ts
new file mode 100644
index 0000000..45de985
--- /dev/null
+++ b/test/util/mockhttp.ts
@@ -0,0 +1,116 @@
+import http from "node:http";
+import https from "node:https";
+
+type MockConfig = {
+  responseDelays?: number[];
+  responseCodes?: number[];
+  username?: string;
+  password?: string;
+  token?: string;
+};
+
+class MockHttp {
+  server: http.Server | https.Server;
+  mockConfig: MockConfig;
+  numOfRequests: number;
+
+  constructor() {
+    this.reset();
+  }
+
+  reset(mockConfig = {}) {
+    this.mockConfig = mockConfig;
+    this.numOfRequests = 0;
+  }
+
+  async start(
+    listenPort: number,
+    secure: boolean = false,
+    options?: Record<string, unknown>,
+  ): Promise<boolean> {
+    const serverCreator = secure ? https.createServer : http.createServer;
+    // @ts-expect-error - Testing different options, so typing is not important
+    this.server = serverCreator(
+      options,
+      (req: http.IncomingMessage, res: http.ServerResponse) => {
+        const authFailed = checkAuthHeader(this.mockConfig, req);
+
+        const body: Uint8Array[] = [];
+        req.on("data", (chunk: Uint8Array) => {
+          body.push(chunk);
+        });
+
+        req.on("end", async () => {
+          console.info(`Received data: ${Buffer.concat(body)}`);
+          this.numOfRequests++;
+
+          const delay =
+            this.mockConfig.responseDelays &&
+            this.mockConfig.responseDelays.length > 0
+              ? this.mockConfig.responseDelays.pop()
+              : undefined;
+          if (delay) {
+            await sleep(delay);
+          }
+
+          const responseCode = authFailed
+            ? 401
+            : this.mockConfig.responseCodes &&
+                this.mockConfig.responseCodes.length > 0
+              ? this.mockConfig.responseCodes.pop()
+              : 204;
+          res.writeHead(responseCode);
+          res.end();
+        });
+      },
+    );
+
+    return new Promise((resolve, reject) => {
+      this.server.listen(listenPort, () => {
+        console.info(`Server is running on port ${listenPort}`);
+        resolve(true);
+      });
+
+      this.server.on("error", (e) => {
+        console.error(`server error: ${e}`);
+        reject(e);
+      });
+    });
+  }
+
+  async stop() {
+    if (this.server) {
+      this.server.close();
+    }
+  }
+}
+
+function checkAuthHeader(mockConfig: MockConfig, req: http.IncomingMessage) {
+  let authFailed = false;
+  const header = (req.headers.authorization || "").split(/\s+/);
+  switch (header[0]) {
+    case "Basic": {
+      const auth = Buffer.from(header[1], "base64").toString().split(/:/);
+      if (mockConfig.username !== auth[0] || mockConfig.password !== auth[1]) {
+        authFailed = true;
+      }
+      break;
+    }
+    case "Bearer":
+      if (mockConfig.token !== header[1]) {
+        authFailed = true;
+      }
+      break;
+    default:
+      if (mockConfig.username || mockConfig.password || mockConfig.token) {
+        authFailed = true;
+      }
+  }
+  return authFailed;
+}
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export { MockHttp };
diff --git a/test/_utils_/mockproxy.ts b/test/util/mockproxy.ts
similarity index 78%
rename from test/_utils_/mockproxy.ts
rename to test/util/mockproxy.ts
index f26e404..0a270e5 100644
--- a/test/_utils_/mockproxy.ts
+++ b/test/util/mockproxy.ts
@@ -1,17 +1,22 @@
+import net, { Socket } from "node:net";
+import tls from "node:tls";
 import { write, listen, shutdown } from "./proxyfunctions";
 
 const CHALLENGE_LENGTH = 512;
 
+type MockConfig = {
+  auth?: boolean;
+  assertions?: boolean;
+};
+
 class MockProxy {
-  mockConfig: {
-    auth?: boolean;
-    assertions?: boolean;
-  };
+  mockConfig: MockConfig;
   dataSentToRemote: string[];
   hasSentChallenge: boolean;
-  client: unknown;
+  client: Socket;
+  server: net.Server | tls.Server;
 
-  constructor(mockConfig) {
+  constructor(mockConfig: MockConfig) {
     if (!mockConfig) {
       throw new Error("Missing mock config");
     }
@@ -19,7 +24,7 @@ class MockProxy {
     this.dataSentToRemote = [];
   }
 
-  async start(listenPort: number, tlsOptions?: Record<string, unknown>) {
+  async start(listenPort: number, tlsOptions?: tls.TlsOptions) {
     await listen(
       this,
       listenPort,
diff --git a/test/_utils_/proxy.ts b/test/util/proxy.ts
similarity index 74%
rename from test/_utils_/proxy.ts
rename to test/util/proxy.ts
index 00394bf..9117813 100644
--- a/test/_utils_/proxy.ts
+++ b/test/util/proxy.ts
@@ -1,17 +1,19 @@
-import { Socket } from "node:net";
+import net, { Socket } from "node:net";
+import tls from "node:tls";
 import { write, listen, shutdown, connect, close } from "./proxyfunctions";
 
 // handles only a single client
 // client -> server (Proxy) -> remote (QuestDB)
 // client <- server (Proxy) <- remote (QuestDB)
 class Proxy {
-  client: unknown;
+  client: Socket;
   remote: Socket;
+  server: net.Server | tls.Server;
 
   constructor() {
     this.remote = new Socket();
 
-    this.remote.on("data", async (data: unknown) => {
+    this.remote.on("data", async (data: string) => {
       console.info(`received from remote, forwarding to client: ${data}`);
       await write(this.client, data);
     });
@@ -20,19 +22,24 @@ class Proxy {
       console.info("remote connection closed");
     });
 
-    this.remote.on("error", (err: unknown) => {
+    this.remote.on("error", (err: Error) => {
       console.error(`remote connection: ${err}`);
     });
   }
 
-  async start(listenPort: unknown, remotePort: unknown, remoteHost: unknown, tlsOptions: Record<string, unknown>) {
+  async start(
+    listenPort: number,
+    remotePort: number,
+    remoteHost: string,
+    tlsOptions: Record<string, unknown>,
+  ) {
     return new Promise<void>((resolve) => {
       this.remote.on("ready", async () => {
         console.info("remote connection ready");
         await listen(
           this,
           listenPort,
-          async (data: unknown) => {
+          async (data: string) => {
             console.info(`received from client, forwarding to remote: ${data}`);
             await write(this.remote, data);
           },
diff --git a/test/_utils_/proxyfunctions.ts b/test/util/proxyfunctions.ts
similarity index 66%
rename from test/_utils_/proxyfunctions.ts
rename to test/util/proxyfunctions.ts
index 0d5fab9..31e33a6 100644
--- a/test/_utils_/proxyfunctions.ts
+++ b/test/util/proxyfunctions.ts
@@ -1,23 +1,24 @@
-import net from "node:net";
-import tls from "node:tls";
+import net, { Socket } from "node:net";
+import tls, { TLSSocket } from "node:tls";
+import { Proxy } from "./proxy";
+import { MockProxy } from "./mockproxy";
 
 const LOCALHOST = "localhost";
 
-async function write(socket, data) {
+async function write(socket: Socket, data: string) {
   return new Promise<void>((resolve, reject) => {
-    socket.write(data, "utf8", (err) => {
-      if (err) {
-        reject(err)
-      } else {
-        resolve();
-      }
-    });
+    socket.write(data, "utf8", (err: Error) => (err ? reject(err) : resolve()));
   });
 }
 
-async function listen(proxy, listenPort, dataHandler, tlsOptions) {
+async function listen(
+  proxy: Proxy | MockProxy,
+  listenPort: number,
+  dataHandler: (data: string) => void,
+  tlsOptions: tls.TlsOptions,
+) {
   return new Promise<void>((resolve) => {
-    const clientConnHandler = (client) => {
+    const clientConnHandler = (client: Socket | TLSSocket) => {
       console.info("client connected");
       if (proxy.client) {
         console.error("There is already a client connected");
@@ -43,7 +44,10 @@ async function listen(proxy, listenPort, dataHandler, tlsOptions) {
   });
 }
 
-async function shutdown(proxy, onServerClose = async () => { }) {
+async function shutdown(
+  proxy: Proxy | MockProxy,
+  onServerClose = async () => {},
+) {
   console.info("closing proxy");
   return new Promise<void>((resolve) => {
     proxy.server.close(async () => {
@@ -53,7 +57,7 @@ async function shutdown(proxy, onServerClose = async () => { }) {
   });
 }
 
-async function connect(proxy, remotePort, remoteHost) {
+async function connect(proxy: Proxy, remotePort: number, remoteHost: string) {
   console.info(`opening remote connection to ${remoteHost}:${remotePort}`);
   return new Promise<void>((resolve) => {
     proxy.remote.connect(remotePort, remoteHost, () => resolve());