wip

2026-03-23 09:26:30 +00:00 · 2023-03-26 14:52:55 -05:00
52 changed files with 2114 additions and 3929 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -46,14 +46,6 @@ jobs:
          POSTGRES_PASSWORD: postgres
          POSTGRES_INITDB_ARGS: --auth-local=scram-sha-256 --auth-host=scram-sha-256 --auth=scram-sha-256

-      - image: postgres:14
-        command: ["postgres", "-p", "10432", "-c", "shared_preload_libraries=pg_stat_statements"]
-        environment:
-          POSTGRES_USER: postgres
-          POSTGRES_DB: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_INITDB_ARGS: --auth-local=md5 --auth-host=md5 --auth=md5
-
    # Add steps to the job
    # See: https://circleci.com/docs/2.0/configuration-reference/#steps
    steps:
--- a/.circleci/pgcat.toml
+++ b/.circleci/pgcat.toml
@@ -39,7 +39,7 @@ log_client_connections = false
 log_client_disconnections = false

 # Reload config automatically if it changes.
-autoreload = 15000
+autoreload = true

 # TLS
 tls_certificate = ".circleci/server.cert"
--- a/.circleci/run_tests.sh
+++ b/.circleci/run_tests.sh
@@ -19,7 +19,6 @@ PGPASSWORD=postgres psql -e -h 127.0.0.1 -p 5432 -U postgres -f tests/sharding/q
 PGPASSWORD=postgres psql -e -h 127.0.0.1 -p 7432 -U postgres -f tests/sharding/query_routing_setup.sql
 PGPASSWORD=postgres psql -e -h 127.0.0.1 -p 8432 -U postgres -f tests/sharding/query_routing_setup.sql
 PGPASSWORD=postgres psql -e -h 127.0.0.1 -p 9432 -U postgres -f tests/sharding/query_routing_setup.sql
-PGPASSWORD=postgres psql -e -h 127.0.0.1 -p 10432 -U postgres -f tests/sharding/query_routing_setup.sql

 PGPASSWORD=sharding_user pgbench -h 127.0.0.1 -U sharding_user shard0 -i
 PGPASSWORD=sharding_user pgbench -h 127.0.0.1 -U sharding_user shard1 -i
@@ -110,10 +109,6 @@ python3 tests/python/tests.py || exit 1

 start_pgcat "info"

-python3 tests/python/async_test.py
-
-start_pgcat "info"
-
 # Admin tests
 export PGPASSWORD=admin_pass
 psql -U admin_user -e -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW STATS' > /dev/null
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,14 +0,0 @@
-root = true
-
-[*]
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.rs]
-indent_style = space
-indent_size = 4
-max_line_length = 120
-
-[*.toml]
-indent_style = space
-indent_size = 2
--- a/.github/workflows/publish-ci-docker-image.yml
+++ b/.github/workflows/publish-ci-docker-image.yml
@@ -15,6 +15,6 @@ jobs:
          password: ${{ secrets.GITHUB_TOKEN }}
      - name: Build CI Docker image
        run: |
-          docker build . -f Dockerfile.ci --tag ghcr.io/postgresml/pgcat-ci:latest
-          docker run ghcr.io/postgresml/pgcat-ci:latest
-          docker push ghcr.io/postgresml/pgcat-ci:latest
+          docker build . -f Dockerfile.ci --tag ghcr.io/levkk/pgcat-ci:latest
+          docker run ghcr.io/levkk/pgcat-ci:latest
+          docker push ghcr.io/levkk/pgcat-ci:latest
--- a/.rustfmt.toml
+++ b/.rustfmt.toml
@@ -1,2 +0,0 @@
-edition = "2021"
-hard_tabs = false
--- a/CONFIG.md
+++ b/CONFIG.md
@@ -49,14 +49,6 @@ default: 30000 # milliseconds

 How long an idle connection with a server is left open (ms).

-### idle_client_in_transaction_timeout
-```
-path: general.idle_client_in_transaction_timeout
-default: 0 # milliseconds
-```
-
-How long a client is allowed to be idle while in a transaction (ms).
-
 ### healthcheck_timeout
 ```
 path: general.healthcheck_timeout
@@ -108,7 +100,7 @@ If we should log client disconnections
 ### autoreload
 ```
 path: general.autoreload
-default: 15000
+default: false
 ```

 When set to true, PgCat reloads configs if it detects a change in the config file.
@@ -152,7 +144,7 @@ default: <UNSET>
 example: "server.cert"
 ```

-Path to TLS Certificate file to use for TLS connections
+Path to TLS Certficate file to use for TLS connections

 ### tls_private_key
 ```
@@ -213,7 +205,7 @@ If the client doesn't specify, PgCat routes traffic to this role by default.
 `replica` round-robin between replicas only without touching the primary,
 `primary` all queries go to the primary unless otherwise specified.

-### query_parser_enabled
+### query_parser_enabled (experimental)
 ```
 path: pools.<pool_name>.query_parser_enabled
 default: true
@@ -234,7 +226,7 @@ If the query parser is enabled and this setting is enabled, the primary will be
 load balancing of read queries. Otherwise, the primary will only be used for write
 queries. The primary can always be explicitly selected with our custom protocol.

-### sharding_key_regex
+### sharding_key_regex (experimental)
 ```
 path: pools.<pool_name>.sharding_key_regex
 default: <UNSET>
@@ -256,40 +248,7 @@ Current options:
 `pg_bigint_hash`: PARTITION BY HASH (Postgres hashing function)
 `sha1`: A hashing function based on SHA1

-### auth_query
-```
-path: pools.<pool_name>.auth_query
-default: <UNSET>
-example: "SELECT $1"
-```
-
-Query to be sent to servers to obtain the hash used for md5 authentication. The connection will be
-established using the database configured in the pool. This parameter is inherited by every pool
-and can be redefined in pool configuration.
-
-### auth_query_user
-```
-path: pools.<pool_name>.auth_query_user
-default: <UNSET>
-example: "sharding_user"
-```
-
-User to be used for connecting to servers to obtain the hash used for md5 authentication by sending the query
-specified in `auth_query_user`. The connection will be established using the database configured in the pool.
-This parameter is inherited by every pool and can be redefined in pool configuration.
-
-### auth_query_password
-```
-path: pools.<pool_name>.auth_query_password
-default: <UNSET>
-example: "sharding_user"
-```
-
-Password to be used for connecting to servers to obtain the hash used for md5 authentication by sending the query
-specified in `auth_query_user`. The connection will be established using the database configured in the pool.
-This parameter is inherited by every pool and can be redefined in pool configuration.
-
-### automatic_sharding_key
+### automatic_sharding_key (experimental)
 ```
 path: pools.<pool_name>.automatic_sharding_key
 default: <UNSET>
@@ -322,8 +281,7 @@ path: pools.<pool_name>.users.<user_index>.username
 default: "sharding_user"
 ```

-PostgreSQL username used to authenticate the user and connect to the server
-if `server_username` is not set.
+Postgresql username

 ### password
 ```
@@ -331,26 +289,7 @@ path: pools.<pool_name>.users.<user_index>.password
 default: "sharding_user"
 ```

-PostgreSQL password used to authenticate the user and connect to the server
-if `server_password` is not set.
-
-### server_username
-```
-path: pools.<pool_name>.users.<user_index>.server_username
-default: <UNSET>
-example: "another_user"
-```
-
-PostgreSQL username used to connect to the server.
-
-### server_password
-```
-path: pools.<pool_name>.users.<user_index>.server_password
-default: <UNSET>
-example: "another_password"
-```
-
-PostgreSQL password used to connect to the server.
+Postgresql password

 ### pool_size
 ```
@@ -381,7 +320,7 @@ default: [["127.0.0.1", 5432, "primary"], ["localhost", 5432, "replica"]]

 Array of servers in the shard, each server entry is an array of `[host, port, role]`

-### mirrors
+### mirrors (experimental)
 ```
 path: pools.<pool_name>.shards.<shard_index>.mirrors
 default: <UNSET>
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 3

 [[package]]
 name = "aho-corasick"
-version = "1.0.1"
+version = "0.7.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67fc08ce920c31afb70f013dcce1bfc3a3195de6a228474e45e1f145b36f8d04"
+checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"
 dependencies = [
 "memchr",
 ]
@@ -28,24 +28,13 @@ checksum = "bddcadddf5e9015d310179a59bb28c4d4b9920ad0f11e8e14dbadf654890c9a6"

 [[package]]
 name = "async-trait"
-version = "0.1.68"
+version = "0.1.66"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9ccdd8f2a161be9bd5c023df56f1b2a0bd1d83872ae53b71a84a12c9bf6e842"
+checksum = "b84f9ebcc6c1f5b8cb160f6990096a5c127f423fcb6e1ccc46c370cbdfb75dfc"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.9",
-]
-
-[[package]]
-name = "atomic_enum"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6227a8d6fdb862bcb100c4314d0d9579e5cd73fa6df31a2e6f6e1acd3c5f1207"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
+ "syn",
 ]

 [[package]]
@@ -94,12 +83,6 @@ version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"

-[[package]]
-name = "byteorder"
-version = "1.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
-
 [[package]]
 name = "bytes"
 version = "1.4.0"
@@ -192,7 +175,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "scratch",
- "syn 1.0.109",
+ "syn",
 ]

 [[package]]
@@ -209,7 +192,7 @@ checksum = "086c685979a698443656e5cf7856c95c642295a38599f12fb1ff76fb28d19892"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 1.0.109",
+ "syn",
 ]

 [[package]]
@@ -263,12 +246,6 @@ version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "de853764b47027c2e862a995c34978ffa63c1501f2e15f987ba11bd4f9bba193"

-[[package]]
-name = "fallible-iterator"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
-
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -277,9 +254,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

 [[package]]
 name = "futures"
-version = "0.3.28"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
+checksum = "13e2792b0ff0340399d58445b88fd9770e3489eff258a4cbc1523418f12abf84"
 dependencies = [
 "futures-channel",
 "futures-core",
@@ -292,9 +269,9 @@ dependencies = [

 [[package]]
 name = "futures-channel"
-version = "0.3.28"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
+checksum = "2e5317663a9089767a1ec00a487df42e0ca174b61b4483213ac24448e4664df5"
 dependencies = [
 "futures-core",
 "futures-sink",
@@ -302,15 +279,15 @@ dependencies = [

 [[package]]
 name = "futures-core"
-version = "0.3.28"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
+checksum = "ec90ff4d0fe1f57d600049061dc6bb68ed03c7d2fbd697274c41805dcb3f8608"

 [[package]]
 name = "futures-executor"
-version = "0.3.28"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0"
+checksum = "e8de0a35a6ab97ec8869e32a2473f4b1324459e14c29275d14b10cb1fd19b50e"
 dependencies = [
 "futures-core",
 "futures-task",
@@ -319,38 +296,38 @@ dependencies = [

 [[package]]
 name = "futures-io"
-version = "0.3.28"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
+checksum = "bfb8371b6fb2aeb2d280374607aeabfc99d95c72edfe51692e42d3d7f0d08531"

 [[package]]
 name = "futures-macro"
-version = "0.3.28"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
+checksum = "95a73af87da33b5acf53acfebdc339fe592ecf5357ac7c0a7734ab9d8c876a70"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.9",
+ "syn",
 ]

 [[package]]
 name = "futures-sink"
-version = "0.3.28"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
+checksum = "f310820bb3e8cfd46c80db4d7fb8353e15dfff853a127158425f31e0be6c8364"

 [[package]]
 name = "futures-task"
-version = "0.3.28"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
+checksum = "dcf79a1bf610b10f42aea489289c5a2c478a786509693b80cd39c44ccd936366"

 [[package]]
 name = "futures-util"
-version = "0.3.28"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
+checksum = "9c1d6de3acfef38d2be4b1f543f553131788603495be83da675e180c8d6b7bd1"
 dependencies = [
 "futures-channel",
 "futures-core",
@@ -387,9 +364,9 @@ dependencies = [

 [[package]]
 name = "h2"
-version = "0.3.17"
+version = "0.3.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66b91535aa35fea1523ad1b86cb6b53c28e0ae566ba4a460f4457e936cad7c6f"
+checksum = "5f9f29bc9dda355256b2916cf526ab02ce0aeaaaf2bad60d65ef3f12f11dd0f4"
 dependencies = [
 "bytes",
 "fnv",
@@ -476,9 +453,9 @@ checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"

 [[package]]
 name = "hyper"
-version = "0.14.26"
+version = "0.14.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab302d72a6f11a3b910431ff93aae7e773078c769f0a3ef15fb9ec692ed147d4"
+checksum = "5e011372fa0b68db8350aa7a248930ecc7839bf46d8485577d69f117a75f164c"
 dependencies = [
 "bytes",
 "futures-channel",
@@ -739,18 +716,16 @@ dependencies = [

 [[package]]
 name = "pgcat"
-version = "1.0.1"
+version = "0.6.0-alpha1"
 dependencies = [
 "arc-swap",
 "async-trait",
- "atomic_enum",
 "base64",
 "bb8",
 "bytes",
 "chrono",
 "env_logger",
 "exitcode",
- "fallible-iterator",
 "futures",
 "hmac",
 "hyper",
@@ -762,7 +737,6 @@ dependencies = [
 "once_cell",
 "parking_lot",
 "phf",
- "postgres-protocol",
 "rand",
 "regex",
 "rustls-pemfile",
@@ -808,7 +782,7 @@ dependencies = [
 "phf_shared",
 "proc-macro2",
 "quote",
- "syn 1.0.109",
+ "syn",
 ]

 [[package]]
@@ -832,24 +806,6 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"

-[[package]]
-name = "postgres-protocol"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78b7fa9f396f51dffd61546fd8573ee20592287996568e6175ceb0f8699ad75d"
-dependencies = [
- "base64",
- "byteorder",
- "bytes",
- "fallible-iterator",
- "hmac",
- "md-5",
- "memchr",
- "rand",
- "sha2",
- "stringprep",
-]
-
 [[package]]
 name = "ppv-lite86"
 version = "0.2.17"
@@ -858,18 +814,18 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"

 [[package]]
 name = "proc-macro2"
-version = "1.0.53"
+version = "1.0.51"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba466839c78239c09faf015484e5cc04860f88242cff4d03eb038f04b4699b73"
+checksum = "5d727cae5b39d21da60fa540906919ad737832fe0b1c165da3a34d6548c849d6"
 dependencies = [
 "unicode-ident",
 ]

 [[package]]
 name = "quote"
-version = "1.0.26"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc"
+checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
 dependencies = [
 "proc-macro2",
 ]
@@ -915,9 +871,9 @@ dependencies = [

 [[package]]
 name = "regex"
-version = "1.8.0"
+version = "1.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac6cf59af1067a3fb53fbe5c88c053764e930f932be1d71d3ffe032cbe147f59"
+checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733"
 dependencies = [
 "aho-corasick",
 "memchr",
@@ -926,9 +882,9 @@ dependencies = [

 [[package]]
 name = "regex-syntax"
-version = "0.7.0"
+version = "0.6.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6868896879ba532248f33598de5181522d8b3d9d724dfd230911e1a7d4822f5"
+checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"

 [[package]]
 name = "ring"
@@ -961,14 +917,14 @@ dependencies = [

 [[package]]
 name = "rustls"
-version = "0.21.0"
+version = "0.20.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07180898a28ed6a7f7ba2311594308f595e3dd2e3c3812fa0a80a47b45f17e5d"
+checksum = "fff78fc74d175294f4e83b28343315ffcfb114b156f0185e9741cb5570f50e2f"
 dependencies = [
 "log",
 "ring",
- "rustls-webpki",
 "sct",
+ "webpki",
 ]

 [[package]]
@@ -980,16 +936,6 @@ dependencies = [
 "base64",
 ]

-[[package]]
-name = "rustls-webpki"
-version = "0.100.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6207cd5ed3d8dca7816f8f3725513a34609c0c765bf652b8c3cb4cfd87db46b"
-dependencies = [
- "ring",
- "untrusted",
-]
-
 [[package]]
 name = "scopeguard"
 version = "1.1.0"
@@ -1014,19 +960,19 @@ dependencies = [

 [[package]]
 name = "serde"
-version = "1.0.160"
+version = "1.0.154"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb2f3770c8bce3bcda7e149193a069a0f4365bda1fa5cd88e03bca26afc1216c"
+checksum = "8cdd151213925e7f1ab45a9bbfb129316bd00799784b174b7cc7bcd16961c49e"

 [[package]]
 name = "serde_derive"
-version = "1.0.160"
+version = "1.0.154"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "291a097c63d8497e00160b166a967a4a79c64f3facdd01cbd7502231688d77df"
+checksum = "4fc80d722935453bcafdc2c9a73cd6fac4dc1938f0346035d84bf99fa9e33217"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.9",
+ "syn",
 ]

 [[package]]
@@ -1108,9 +1054,9 @@ checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"

 [[package]]
 name = "sqlparser"
-version = "0.33.0"
+version = "0.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "355dc4d4b6207ca8a3434fc587db0a8016130a574dbcdbfb93d7f7b5bc5b211a"
+checksum = "0366f270dbabb5cc2e4c88427dc4c08bba144f81e32fbd459a013f26a4d16aa0"
 dependencies = [
 "log",
 ]
@@ -1148,17 +1094,6 @@ dependencies = [
 "unicode-ident",
 ]

-[[package]]
-name = "syn"
-version = "2.0.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0da4a3c17e109f700685ec577c0f85efd9b19bcf15c913985f14dc1ac01775aa"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
 [[package]]
 name = "termcolor"
 version = "1.2.0"
@@ -1222,17 +1157,18 @@ checksum = "d266c00fde287f55d3f1c3e96c500c362a2b8c695076ec180f27918820bc6df8"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 1.0.109",
+ "syn",
 ]

 [[package]]
 name = "tokio-rustls"
-version = "0.24.0"
+version = "0.23.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0d409377ff5b1e3ca6437aa86c1eb7d40c134bfec254e44c830defa92669db5"
+checksum = "c43ee83903113e03984cb9e5cebe6c04a5116269e900e3ddba8f068a62adda59"
 dependencies = [
 "rustls",
 "tokio",
+ "webpki",
 ]

 [[package]]
@@ -1251,9 +1187,9 @@ dependencies = [

 [[package]]
 name = "toml"
-version = "0.7.3"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b403acf6f2bb0859c93c7f0d967cb4a75a7ac552100f9322faf64dc047669b21"
+checksum = "f7afcae9e3f0fe2c370fd4657108972cbb2fa9db1b9f84849cefd80741b01cb6"
 dependencies = [
 "serde",
 "serde_spanned",
@@ -1272,9 +1208,9 @@ dependencies = [

 [[package]]
 name = "toml_edit"
-version = "0.19.6"
+version = "0.19.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08de71aa0d6e348f070457f85af8bd566e2bc452156a423ddf22861b3a953fae"
+checksum = "9a1eb0622d28f4b9c90adc4ea4b2b46b47663fde9ac5fafcb14a1369d5508825"
 dependencies = [
 "indexmap",
 "serde",
@@ -1403,7 +1339,7 @@ dependencies = [
 "once_cell",
 "proc-macro2",
 "quote",
- "syn 1.0.109",
+ "syn",
 "wasm-bindgen-shared",
 ]

@@ -1425,7 +1361,7 @@ checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 1.0.109",
+ "syn",
 "wasm-bindgen-backend",
 "wasm-bindgen-shared",
 ]
@@ -1446,6 +1382,16 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "webpki"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,10 @@
 [package]
 name = "pgcat"
-version = "1.0.1"
+version = "0.6.0-alpha1"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
 [dependencies]
 tokio = { version = "1", features = ["full"] }
 bytes = "1"
@@ -19,7 +20,7 @@ serde_derive = "1"
 regex = "1"
 num_cpus = "1"
 once_cell = "1"
-sqlparser = "0.33.0"
+sqlparser = "0.32.0"
 log = "0.4"
 arc-swap = "1"
 env_logger = "0.10"
@@ -28,7 +29,7 @@ hmac = "0.12"
 sha2 = "0.10"
 base64 = "0.21"
 stringprep = "0.1"
-tokio-rustls = "0.24"
+tokio-rustls = "0.23"
 rustls-pemfile = "1"
 hyper = { version = "0.14", features = ["full"] }
 phf = { version = "0.11.1", features = ["macros"] }
@@ -36,9 +37,6 @@ exitcode = "1.1.2"
 futures = "0.3"
 socket2 = { version = "0.4.7", features = ["all"] }
 nix = "0.26.2"
-atomic_enum = "0.2.0"
-postgres-protocol = "0.6.5"
-fallible-iterator = "0.2"

 [target.'cfg(not(target_env = "msvc"))'.dependencies]
 jemallocator = "0.5.0"
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-Copyright (c) 2023 PgCat Contributors
+Copyright (c) 2022 Lev Kokotov <lev@levthe.dev>

 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
--- a/README.md
+++ b/README.md
@@ -1,80 +1,33 @@
-## PgCat: Nextgen PostgreSQL Pooler
+##### PgCat: PostgreSQL at petabyte scale

-[![CircleCI](https://circleci.com/gh/postgresml/pgcat/tree/main.svg?style=svg)](https://circleci.com/gh/postgresml/pgcat/tree/main)
+[![CircleCI](https://circleci.com/gh/levkk/pgcat/tree/main.svg?style=svg)](https://circleci.com/gh/levkk/pgcat/tree/main)
 <a href="https://discord.gg/DmyJP3qJ7U" target="_blank">
    <img src="https://img.shields.io/discord/1013868243036930099" alt="Join our Discord!" />
 </a>

-PostgreSQL pooler and proxy (like PgBouncer) with support for sharding, load balancing, failover and mirroring.
+PostgreSQL pooler (like PgBouncer) with sharding, load balancing and failover support.
+
+**Beta**: looking for beta testers, see [#35](https://github.com/levkk/pgcat/issues/35).

 ## Features
-
-| **Feature** | **Status** | **Comments** |
-|-------------|------------|--------------|
-| Transaction pooling | **Stable** | Identical to PgBouncer with notable improvements for handling bad clients and abandoned transactions. |
-| Session pooling | **Stable** | Identical to PgBouncer. |
-| Multi-threaded runtime | **Stable** | Using Tokio asynchronous runtime, the pooler takes advantage of multicore machines. |
-| Load balancing of read queries | **Stable** | Queries are automatically load balanced between replicas and the primary. |
-| Failover | **Stable** | Queries are automatically rerouted around broken replicas, validated by regular health checks. |
-| Admin database statistics | **Stable** | Pooler statistics and administration via the `pgbouncer` and `pgcat` databases. |
-| Prometheus statistics | **Stable** | Statistics are reported via a HTTP endpoint for Prometheus. |
-| Client TLS | **Stable** | Clients can connect to the pooler using TLS/SSL. |
-| Client/Server authentication | **Stable** | Clients can connect using MD5 authentication, supported by `libpq` and all Postgres client drivers. PgCat can connect to Postgres using MD5 and SCRAM-SHA-256. |
-| Live configuration reloading | **Stable** | Identical to PgBouncer; all settings can be reloaded dynamically (except `host` and `port`). |
-| Auth passthrough | **Stable** | MD5 password authentication can be configured to use an `auth_query` so no cleartext passwords are needed in the config file.|
-| Sharding using extended SQL syntax | **Experimental** | Clients can dynamically configure the pooler to route queries to specific shards. |
-| Sharding using comments parsing/Regex | **Experimental** | Clients can include shard information (sharding key, shard ID) in the query comments. |
-| Automatic sharding | **Experimental** | PgCat can parse queries, detect sharding keys automatically, and route queries to the correct shard. |
-| Mirroring | **Experimental** | Mirror queries between multiple databases in order to test servers with realistic production traffic. |
-
-
-## Status
-
-PgCat is stable and used in production to serve hundreds of thousands of queries per second.
-
-<table>
-  <tr>
-    <td>
-      <a href="https://tech.instacart.com/adopting-pgcat-a-nextgen-postgres-proxy-3cf284e68c2f">
-        <img src="./images/instacart.webp" height="70" width="auto">
-      </a>
-    </td>
-    <td>
-      <a href="https://postgresml.org/blog/scaling-postgresml-to-one-million-requests-per-second">
-        <img src="./images/postgresml.webp" height="70" width="auto">
-      </a>
-    </td>
-    <td>
-      <a href="https://onesignal.com">
-        <img src="./images/one_signal.webp" height="70" width="auto">
-      </a>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <a href="https://tech.instacart.com/adopting-pgcat-a-nextgen-postgres-proxy-3cf284e68c2f">
-        Instacart
-      </a>
-    </td>
-    <td>
-      <a href="https://postgresml.org/blog/scaling-postgresml-to-one-million-requests-per-second">
-        PostgresML
-      </a>
-    </td>
-    <td>
-      OneSignal
-    </td>
-  </tr>
-</table>
-
-Some features remain experimental and are being actively developed. They are optional and can be enabled through configuration.
+| **Feature**                    | **Status**                  | **Comments**                                                                                                                                          |
+|--------------------------------|-----------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Transaction pooling            | :white_check_mark:          | Identical to PgBouncer.                                                                                                                               |
+| Session pooling                | :white_check_mark:          | Identical to PgBouncer.                                                                                                                               |
+| `COPY` support                 | :white_check_mark:          | Both `COPY TO` and `COPY FROM` are supported.                                                                                                         |
+| Query cancellation             | :white_check_mark:          | Supported both in transaction and session pooling modes.                                                                                              |
+| Load balancing of read queries | :white_check_mark:          | Using random between replicas. Primary is included when `primary_reads_enabled` is enabled (default).                                            |
+| Sharding                       | :white_check_mark:          | Transactions are sharded using `SET SHARD TO` and `SET SHARDING KEY TO` syntax extensions; see examples below.                                        |
+| Failover                       | :white_check_mark:          | Replicas are tested with a health check. If a health check fails, remaining replicas are attempted; see below for algorithm description and examples. |
+| Statistics                     | :white_check_mark:          | Statistics available in the admin database (`pgcat` and `pgbouncer`) with `SHOW STATS`, `SHOW POOLS` and others.                                      |
+| Live configuration reloading   | :white_check_mark:          | Reload supported settings with a `SIGHUP` to the process, e.g. `kill -s SIGHUP $(pgrep pgcat)` or `RELOAD` query issued to the admin database.        |
+| Client authentication          | :white_check_mark: :wrench: | MD5 password authentication is supported, SCRAM is on the roadmap; one user is used to connect to Postgres with both SCRAM and MD5 supported.         |
+| Admin database                 | :white_check_mark:          | The admin database, similar to PgBouncer's, allows to query for statistics and reload the configuration.                                              |

 ## Deployment

 See `Dockerfile` for example deployment using Docker. The pooler is configured to spawn 4 workers so 4 CPUs are recommended for optimal performance. That setting can be adjusted to spawn as many (or as little) workers as needed.

-A Docker image is available from `docker pull ghcr.io/postgresml/pgcat:latest`. See our [Github packages repository](https://github.com/postgresml/pgcat/pkgs/container/pgcat).
-
 For quick local example, use the Docker Compose environment provided:

 ```bash
@@ -86,13 +39,9 @@ PGPASSWORD=postgres psql -h 127.0.0.1 -p 6432 -U postgres -c 'SELECT 1'

 ### Config

-See **[Configuration](https://github.com/levkk/pgcat/blob/main/CONFIG.md)**.
+See [Configurations page](https://github.com/levkk/pgcat/blob/main/CONFIG.md)

-## Contributing
-
-The project is being actively developed and looking for additional contributors and production deployments.
-
-### Local development
+## Local development

 1. Install Rust (latest stable will work great).
 2. `cargo build --release` (to get better benchmarks).
@@ -102,7 +51,7 @@ The project is being actively developed and looking for additional contributors

 ### Tests

-When making substantial modifications to the protocol implementation, make sure to test them with pgbench:
+Quickest way to test your changes is to use pgbench:

 ```
 pgbench -i -h 127.0.0.1 -p 6432 && \
@@ -112,26 +61,36 @@ pgbench -t 1000 -p 6432 -h 127.0.0.1 --protocol extended

 See [sharding README](./tests/sharding/README.md) for sharding logic testing.

-Additionally, all features are tested with Ruby, Python, and Rust unit and integration tests.
-
-Run `cargo test` to run Rust unit tests.
-
-Run the following commands to run Ruby and Python integration tests:
+Run `cargo test` to run Rust tests.

+Run the following commands to run Integration tests locally.
 ```
 cd tests/docker/
 docker compose up --exit-code-from main # This will also produce coverage report under ./cov/
 ```

-### Docker-based local development
+| **Feature**           | **Tested in CI**   | **Tested manually** | **Comments**                                                                                                             |
+|-----------------------|--------------------|---------------------|--------------------------------------------------------------------------------------------------------------------------|
+| Transaction pooling   | :white_check_mark: | :white_check_mark:  | Used by default for all tests.                                                                                           |
+| Session pooling       | :white_check_mark: | :white_check_mark:  | Tested by running pgbench with `--protocol prepared` which only works in session mode.                                   |
+| `COPY`                | :white_check_mark: | :white_check_mark:  | `pgbench -i` uses `COPY`. `COPY FROM` is tested as well.                                                                 |
+| Query cancellation    | :white_check_mark: | :white_check_mark:  | `psql -c 'SELECT pg_sleep(1000);'` and press `Ctrl-C`.                                                                   |
+| Load balancing        | :white_check_mark: | :white_check_mark:  | We could test this by emitting statistics for each replica and compare them.                                             |
+| Failover              | :white_check_mark: | :white_check_mark:  | Misconfigure a replica in `pgcat.toml` and watch it forward queries to spares. CI testing is using Toxiproxy.            |
+| Sharding              | :white_check_mark: | :white_check_mark:  | See `tests/sharding` and `tests/ruby` for an Rails/ActiveRecord example.                                                 |
+| Statistics            | :white_check_mark: | :white_check_mark:  | Query the admin database with `psql -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW STATS'`.                                  |
+| Live config reloading | :white_check_mark: | :white_check_mark:  | Run `kill -s SIGHUP $(pgrep pgcat)` and watch the config reload.                                                         |

-You can open a Docker development environment where you can debug tests easier. Run the following command to spin it up:
+### Dev
+
+Also, you can open a 'dev' environment where you can debug tests easier by running the following command:

 ```
 ./dev/script/console
 ```

-This will open a terminal in an environment similar to that used in tests. In there, you can compile the pooler, run tests, do some debugging with the test environment, etc. Objects compiled inside the container (and bundled gems) will be placed in `dev/cache` so they don't interfere with what you have on your machine.
+This will open a terminal in an environment similar to that used in tests. In there you can compile, run tests, do some debugging with the test environment, etc. Objects
+compiled inside the contaner (and bundled gems) will be placed in `dev/cache` so they don't interfere with what you have in your host.

 ## Usage

@@ -146,9 +105,11 @@ In transaction mode, a client talks to one server for the duration of a single t
 This mode is enabled by default.

 ### Load balancing of read queries
-All queries are load balanced against the configured servers using either the random or least open connections algorithms. The most straightforward configuration example would be to put this pooler in front of several replicas and let it load balance all queries.
+All queries are load balanced against the configured servers using the random algorithm. The most straight forward configuration example would be to put this pooler in front of several replicas and let it load balance all queries.

-If the configuration includes a primary and replicas, the queries can be separated with the built-in query parser. The query parser, implemented with the `sqlparser` crate, will interpret the query and route all `SELECT` queries to a replica, while all other queries including explicit transactions will be routed to the primary.
+If the configuration includes a primary and replicas, the queries can be separated with the built-in query parser. The query parser will interpret the query and route all `SELECT` queries to a replica, while all other queries including explicit transactions will be routed to the primary.
+
+The query parser is disabled by default.

 #### Query parser
 The query parser will do its best to determine where the query should go, but sometimes that's not possible. In that case, the client can select which server it wants using this custom SQL syntax:
@@ -175,14 +136,38 @@ The setting will persist until it's changed again or the client disconnects.
 By default, all queries are routed to the first available server; `default_role` setting controls this behavior.

 ### Failover
-All servers are checked with a `;` (very fast) query before being given to a client. Additionally, the server health is monitored with every client query that it processes. If the server is not reachable, it will be banned and cannot serve any more transactions for the duration of the ban. The queries are routed to the remaining servers. If all servers become banned, the ban list is cleared: this is a safety precaution against false positives. The primary can never be banned.
+All servers are checked with a `SELECT 1` query before being given to a client. If the server is not reachable, it will be banned and cannot serve any more transactions for the duration of the ban. The queries are routed to the remaining servers. If all servers become banned, the ban list is cleared: this is a safety precaution against false positives. The primary can never be banned.

 The ban time can be changed with `ban_time`. The default is 60 seconds.

+Failover behavior can get pretty interesting (read complex) when multiple configurations and factors are involved. The table below will try to explain what PgCat does in each scenario:
+
+| **Query**                 | **`SET SERVER ROLE TO`** | **`query_parser_enabled`** | **`primary_reads_enabled`** | **Target state** | **Outcome**                                                                                                                                                          |
+|---------------------------|--------------------------|----------------------------|-----------------------------|------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Read query, i.e. `SELECT` | unset (any)              | false                      | false                       | up               | Query is routed to the first instance in the random loop.                                                                                                       |
+| Read query                | unset (any)              | true                       | false                       | up               | Query is routed to the first replica instance in the random loop.                                                                                               |
+| Read query                | unset (any)              | true                       | true                        | up               | Query is routed to the first instance in the random loop.                                                                                                       |
+| Read query                | replica                  | false                      | false                       | up               | Query is routed to the first replica instance in the random loop.                                                                                               |
+| Read query                | primary                  | false                      | false                       | up               | Query is routed to the primary.                                                                                                                                      |
+| Read query                | unset (any)              | false                      | false                       | down             | First instance is banned for reads. Next target in the random loop is attempted.                                                                                |
+| Read query                | unset (any)              | true                       | false                       | down             | First replica instance is banned. Next replica instance is attempted in the random loop.                                                                        |
+| Read query                | unset (any)              | true                       | true                        | down             | First instance (even if primary) is banned for reads. Next instance is attempted in the random loop.                                                            |
+| Read query                | replica                  | false                      | false                       | down             | First replica instance is banned. Next replica instance is attempted in the random loop.                                                                        |
+| Read query                | primary                  | false                      | false                       | down             | The query is attempted against the primary and fails. The client receives an error.                                                                                  |
+|                           |                          |                            |                             |                  |                                                                                                                                                                      |
+| Write query e.g. `INSERT` | unset (any)              | false                      | false                       | up               | The query is attempted against the first available instance in the random loop. If the instance is a replica, the query fails and the client receives an error. |
+| Write query               | unset (any)              | true                       | false                       | up               | The query is routed to the primary.                                                                                                                                  |
+| Write query               | unset (any)              | true                       | true                        | up               | The query is routed to the primary.                                                                                                                                  |
+| Write query               | primary                  | false                      | false                       | up               | The query is routed to the primary.                                                                                                                                  |
+| Write query               | replica                  | false                      | false                       | up               | The query is routed to the replica and fails. The client receives an error.                                                                                          |
+| Write query               | unset (any)              | true                       | false                       | down             | The query is routed to the primary and fails. The client receives an error.                                                                                          |
+| Write query               | unset (any)              | true                       | true                        | down             | The query is routed to the primary and fails. The client receives an error.                                                                                          |
+| Write query               | primary                  | false                      | false                       | down             | The query is routed to the primary and fails. The client receives an error.                                                                                          |
+|                           |                          |                            |                             |                  |                                                                                                                                                                      |
+
 ### Sharding
 We use the `PARTITION BY HASH` hashing function, the same as used by Postgres for declarative partitioning. This allows to shard the database using Postgres partitions and place the partitions on different servers (shards). Both read and write queries can be routed to the shards using this pooler.

-#### Extended syntax
 To route queries to a particular shard, we use this custom SQL syntax:

 ```sql
@@ -197,8 +182,7 @@ The active shard will last until it's changed again or the client disconnects. B

 For hash function implementation, see `src/sharding.rs` and `tests/sharding/partition_hash_test_setup.sql`.

-
-##### ActiveRecord/Rails
+#### ActiveRecord/Rails

 ```ruby
 class User < ActiveRecord::Base
@@ -226,7 +210,7 @@ User.connection.execute "SET SERVER ROLE TO 'auto'"
 User.find_by_email("test@example.com")
 ```

-##### Raw SQL
+#### Raw SQL

 ```sql
 -- Grab a bunch of users from shard 1
@@ -246,45 +230,268 @@ SET SERVER ROLE TO 'auto'; -- let the query router figure out where the query sh
 SELECT * FROM users WHERE email = 'test@example.com'; -- shard setting lasts until set again; we are reading from the primary
 ```

-#### With comments
-Issuing queries to the pooler can cause additional latency. To reduce its impact, it's possible to include sharding information inside SQL comments sent via the query. This is reasonably easy to implement with ORMs like [ActiveRecord](https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-annotate) and [SQLAlchemy](https://docs.sqlalchemy.org/en/20/core/events.html#sql-execution-and-connection-events).
-
-```
-/* shard_id: 5 */ SELECT * FROM foo WHERE id = 1234;
-
-/* sharding_key: 1234 */ SELECT * FROM foo WHERE id = 1234;
-```
-
-#### Automatic query parsing
-PgCat can use the `sqlparser` crate to parse SQL queries and extract the sharding key. This is configurable with the `automatic_sharding_key` setting. This feature is still experimental, but it's the ideal implementation for sharding, requiring no client modifications.
-
 ### Statistics reporting

-The stats are very similar to what PgBouncer reports and the names are kept to be comparable. They are accessible by querying the admin database `pgcat`, and `pgbouncer` for compatibility.
+The stats are very similar to what Pgbouncer reports and the names are kept to be comparable. They are accessible by querying the admin database `pgcat`, and `pgbouncer` for compatibility.

 ```
 psql -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW DATABASES'
 ```

-Additionally, Prometheus statistics are available at `/metrics` via HTTP.
-
 ### Live configuration reloading

-The config can be reloaded by sending a `kill -s SIGHUP` to the process or by querying `RELOAD` to the admin database. All settings except the `host` and `port` can be reloaded without restarting the pooler, including sharding and replicas configurations.
+The config can be reloaded by sending a `kill -s SIGHUP` to the process or by querying `RELOAD` to the admin database. Not all settings are currently supported by live reload:

-### Mirroring
+| **Config**              | **Requires restart** |
+|-------------------------|----------------------|
+| `host`                  | yes                  |
+| `port`                  | yes                  |
+| `pool_mode`             | no                   |
+| `connect_timeout`       | yes                  |
+| `healthcheck_timeout`   | no                   |
+| `shutdown_timeout`      | no                   |
+| `healthcheck_delay`     | no                   |
+| `ban_time`              | no                   |
+| `user`                  | yes                  |
+| `shards`                | yes                  |
+| `default_role`          | no                   |
+| `primary_reads_enabled` | no                   |
+| `query_parser_enabled`  | no                   |

-Mirroring allows to route queries to multiple databases at the same time. This is useful for prewarning replicas before placing them into the active configuration, or for testing different versions of Postgres with live traffic.

-## License
+## Benchmarks

-PgCat is free and open source, released under the MIT license.
+You can setup PgBench locally through PgCat:

-## Contributors
+```
+pgbench -h 127.0.0.1 -p 6432 -i
+```

-Many thanks to our amazing contributors!
+Coincidenly, this uses `COPY` so you can test if that works. Additionally, we'll be running the following PgBench configurations:

-<a href = "https://github.com/postgresml/pgcat/graphs/contributors">
-  <img src = "https://contrib.rocks/image?repo=postgresml/pgcat"/>
-</a>
+1. 16 clients, 2 threads
+2. 32 clients, 2 threads
+3. 64 clients, 2 threads
+4. 128 clients, 2 threads

+All queries will be `SELECT` only (`-S`) just so disks don't get in the way, since the dataset will be effectively all in RAM.
+
+My setup:
+
+- 8 cores, 16 hyperthreaded (AMD Ryzen 5800X)
+- 32GB RAM (doesn't matter for this benchmark, except to prove that Postgres will fit the whole dataset into RAM)
+
+### PgBouncer
+
+#### Config
+
+```ini
+[databases]
+shard0 = host=localhost port=5432 user=sharding_user password=sharding_user
+
+[pgbouncer]
+pool_mode = transaction
+max_client_conn = 1000
+```
+
+Everything else stays default.
+
+#### Runs
+
+
+```
+$ pgbench -t 1000 -c 16 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended shard0
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 16
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 16000/16000
+latency average = 0.155 ms
+tps = 103417.377469 (including connections establishing)
+tps = 103510.639935 (excluding connections establishing)
+
+
+$ pgbench -t 1000 -c 32 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended shard0
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 32
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 32000/32000
+latency average = 0.290 ms
+tps = 110325.939785 (including connections establishing)
+tps = 110386.513435 (excluding connections establishing)
+
+
+$ pgbench -t 1000 -c 64 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended shard0
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 64
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 64000/64000
+latency average = 0.692 ms
+tps = 92470.427412 (including connections establishing)
+tps = 92618.389350 (excluding connections establishing)
+
+$ pgbench -t 1000 -c 128 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended shard0
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 128
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 128000/128000
+latency average = 1.406 ms
+tps = 91013.429985 (including connections establishing)
+tps = 91067.583928 (excluding connections establishing)
+```
+
+### PgCat
+
+#### Config
+
+The only thing that matters here is the number of workers in the Tokio pool. Make sure to set it to < than the number of your CPU cores.
+Also account for hyper-threading, so if you have that, take the number you got above and divide it by two, that way only "real" cores serving
+requests.
+
+My setup is 16 threads, 8 cores (`htop` shows as 16 CPUs), so I set the `max_workers` in Tokio to 4. Too many, and it starts conflicting with PgBench
+which is also running on the same system.
+
+#### Runs
+
+
+```
+$ pgbench -t 1000 -c 16 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 16
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 16000/16000
+latency average = 0.164 ms
+tps = 97705.088232 (including connections establishing)
+tps = 97872.216045 (excluding connections establishing)
+
+
+$ pgbench -t 1000 -c 32 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 32
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 32000/32000
+latency average = 0.288 ms
+tps = 111300.488119 (including connections establishing)
+tps = 111413.107800 (excluding connections establishing)
+
+
+$ pgbench -t 1000 -c 64 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 64
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 64000/64000
+latency average = 0.556 ms
+tps = 115190.496139 (including connections establishing)
+tps = 115247.521295 (excluding connections establishing)
+
+$ pgbench -t 1000 -c 128 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 128
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 128000/128000
+latency average = 1.135 ms
+tps = 112770.562239 (including connections establishing)
+tps = 112796.502381 (excluding connections establishing)
+```
+
+### Direct Postgres
+
+Always good to have a base line.
+
+#### Runs
+
+```
+$ pgbench -t 1000 -c 16 -j 2 -p 5432 -h 127.0.0.1 -S --protocol extended shard0
+Password:
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 16
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 16000/16000
+latency average = 0.115 ms
+tps = 139443.955722 (including connections establishing)
+tps = 142314.859075 (excluding connections establishing)
+
+$ pgbench -t 1000 -c 32 -j 2 -p 5432 -h 127.0.0.1 -S --protocol extended shard0
+Password:
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 32
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 32000/32000
+latency average = 0.212 ms
+tps = 150644.840891 (including connections establishing)
+tps = 152218.499430 (excluding connections establishing)
+
+$ pgbench -t 1000 -c 64 -j 2 -p 5432 -h 127.0.0.1 -S --protocol extended shard0
+Password:
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 64
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 64000/64000
+latency average = 0.420 ms
+tps = 152517.663404 (including connections establishing)
+tps = 153319.188482 (excluding connections establishing)
+
+$ pgbench -t 1000 -c 128 -j 2 -p 5432 -h 127.0.0.1 -S --protocol extended shard0
+Password:
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 128
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 128000/128000
+latency average = 0.854 ms
+tps = 149818.594087 (including connections establishing)
+tps = 150200.603049 (excluding connections establishing)
+```
--- a/dev/docker-compose.yaml
+++ b/dev/docker-compose.yaml
@@ -26,8 +26,6 @@ x-common-env-pg:
 services:
  main:
    image: kubernetes/pause
-    ports:
-      - 6432

  pg1:
    <<: *common-definition-pg
@@ -58,13 +56,6 @@ services:
      POSTGRES_INITDB_ARGS: --auth-local=scram-sha-256 --auth-host=scram-sha-256 --auth=scram-sha-256
      PGPORT: 9432
    command: ["postgres", "-p", "9432", "-c", "shared_preload_libraries=pg_stat_statements", "-c", "pg_stat_statements.track=all", "-c", "pg_stat_statements.max=100000"]
-  pg5:
-    <<: *common-definition-pg
-    environment:
-      <<: *common-env-pg
-      POSTGRES_INITDB_ARGS: --auth-local=md5 --auth-host=md5 --auth=md5
-      PGPORT: 10432
-    command: ["postgres", "-p", "5432", "-c", "shared_preload_libraries=pg_stat_statements", "-c", "pg_stat_statements.track=all", "-c", "pg_stat_statements.max=100000"]

  toxiproxy:
    build: .
@@ -78,7 +69,6 @@ services:
      - pg2
      - pg3
      - pg4
-      - pg5

  pgcat-shell:
    stdin_open: true
--- a/examples/docker/pgcat.toml
+++ b/examples/docker/pgcat.toml
@@ -38,6 +38,9 @@ log_client_connections = false
 # If we should log client disconnections
 log_client_disconnections = false

+# Reload config automatically if it changes.
+autoreload = false
+
 # TLS
 # tls_certificate = "server.cert"
 # tls_private_key = "server.key"
@@ -73,7 +76,7 @@ query_parser_enabled = true

 # If the query parser is enabled and this setting is enabled, the primary will be part of the pool of databases used for
 # load balancing of read queries. Otherwise, the primary will only be used for write
-# queries. The primary can always be explicitly selected with our custom protocol.
+# queries. The primary can always be explicitely selected with our custom protocol.
 primary_reads_enabled = true

 # So what if you wanted to implement a different hashing function,
--- a/images/instacart.webp
+++ b/images/instacart.webp
--- a/images/one_signal.webp
+++ b/images/one_signal.webp
--- a/images/postgresml.webp
+++ b/images/postgresml.webp
--- a/pgcat.toml
+++ b/pgcat.toml
@@ -23,9 +23,6 @@ connect_timeout = 5000 # milliseconds
 # How long an idle connection with a server is left open (ms).
 idle_timeout = 30000 # milliseconds

-# How long a client is allowed to be idle while in a transaction (ms).
-idle_client_in_transaction_timeout = 0 # milliseconds
-
 # How much time to give the health check query to return with a result (ms).
 healthcheck_timeout = 1000 # milliseconds

@@ -45,7 +42,7 @@ log_client_connections = false
 log_client_disconnections = false

 # When set to true, PgCat reloads configs if it detects a change in the config file.
-autoreload = 15000
+autoreload = false

 # Number of worker threads the Runtime will use (4 by default).
 worker_threads = 5
@@ -57,7 +54,7 @@ tcp_keepalives_count = 5
 # Number of seconds between keepalive packets.
 tcp_keepalives_interval = 5

-# Path to TLS Certificate file to use for TLS connections
+# Path to TLS Certficate file to use for TLS connections
 # tls_certificate = "server.cert"
 # Path to TLS private key file to use for TLS connections
 # tls_private_key = "server.key"
@@ -113,21 +110,6 @@ primary_reads_enabled = true
 # `sha1`: A hashing function based on SHA1
 sharding_function = "pg_bigint_hash"

-# Query to be sent to servers to obtain the hash used for md5 authentication. The connection will be
-# established using the database configured in the pool. This parameter is inherited by every pool
-# and can be redefined in pool configuration.
-# auth_query = "SELECT $1"
-
-# User to be used for connecting to servers to obtain the hash used for md5 authentication by sending the query
-# specified in `auth_query_user`. The connection will be established using the database configured in the pool.
-# This parameter is inherited by every pool and can be redefined in pool configuration.
-# auth_query_user = "sharding_user"
-
-# Password to be used for connecting to servers to obtain the hash used for md5 authentication by sending the query
-# specified in `auth_query_user`. The connection will be established using the database configured in the pool.
-# This parameter is inherited by every pool and can be redefined in pool configuration.
-# auth_query_password = "sharding_user"
-
 # Automatically parse this from queries and route queries to the right shard!
 # automatic_sharding_key = "data.id"

@@ -138,30 +120,17 @@ idle_timeout = 40000
 connect_timeout = 3000

 # User configs are structured as pool.<pool_name>.users.<user_index>
-# This section holds the credentials for users that may connect to this cluster
+# This secion holds the credentials for users that may connect to this cluster
 [pools.sharded_db.users.0]
-# PostgreSQL username used to authenticate the user and connect to the server
-# if `server_username` is not set.
+# Postgresql username
 username = "sharding_user"
-
-# PostgreSQL password used to authenticate the user and connect to the server
-# if `server_password` is not set.
+# Postgresql password
 password = "sharding_user"
-
-pool_mode = "session"
-
-# PostgreSQL username used to connect to the server.
-# server_username = "another_user"
-
-# PostgreSQL password used to connect to the server.
-# server_password = "another_password"
-
 # Maximum number of server connections that can be established for this user
 # The maximum number of connection from a single Pgcat process to any database in the cluster
 # is the sum of pool_size across all users.
 pool_size = 9

-
 # Maximum query duration. Dangerous, but protects against DBs that died in a non-obvious way.
 # 0 means it is disabled.
 statement_timeout = 0
--- a/src/admin.rs
+++ b/src/admin.rs
@@ -1,11 +1,10 @@
 use crate::pool::BanReason;
+/// Admin database.
 use bytes::{Buf, BufMut, BytesMut};
 use log::{error, info, trace};
 use nix::sys::signal::{self, Signal};
 use nix::unistd::Pid;
 use std::collections::HashMap;
-/// Admin database.
-use std::sync::atomic::Ordering;
 use std::time::{SystemTime, UNIX_EPOCH};
 use tokio::time::Instant;

@@ -13,7 +12,9 @@ use crate::config::{get_config, reload_config, VERSION};
 use crate::errors::Error;
 use crate::messages::*;
 use crate::pool::{get_all_pools, get_pool};
-use crate::stats::{get_client_stats, get_pool_stats, get_server_stats, ClientState, ServerState};
+use crate::stats::{
+    get_address_stats, get_client_stats, get_pool_stats, get_server_stats, ClientState, ServerState,
+};
 use crate::ClientServerMap;

 pub fn generate_server_info_for_admin() -> BytesMut {
@@ -157,14 +158,7 @@ where
        "free_clients".to_string(),
        client_stats
            .keys()
-            .filter(|client_id| {
-                client_stats
-                    .get(client_id)
-                    .unwrap()
-                    .state
-                    .load(Ordering::Relaxed)
-                    == ClientState::Idle
-            })
+            .filter(|client_id| client_stats.get(client_id).unwrap().state == ClientState::Idle)
            .count()
            .to_string(),
    ]));
@@ -172,14 +166,7 @@ where
        "used_clients".to_string(),
        client_stats
            .keys()
-            .filter(|client_id| {
-                client_stats
-                    .get(client_id)
-                    .unwrap()
-                    .state
-                    .load(Ordering::Relaxed)
-                    == ClientState::Active
-            })
+            .filter(|client_id| client_stats.get(client_id).unwrap().state == ClientState::Active)
            .count()
            .to_string(),
    ]));
@@ -191,14 +178,7 @@ where
        "free_servers".to_string(),
        server_stats
            .keys()
-            .filter(|server_id| {
-                server_stats
-                    .get(server_id)
-                    .unwrap()
-                    .state
-                    .load(Ordering::Relaxed)
-                    == ServerState::Idle
-            })
+            .filter(|server_id| server_stats.get(server_id).unwrap().state == ServerState::Idle)
            .count()
            .to_string(),
    ]));
@@ -206,14 +186,7 @@ where
        "used_servers".to_string(),
        server_stats
            .keys()
-            .filter(|server_id| {
-                server_stats
-                    .get(server_id)
-                    .unwrap()
-                    .state
-                    .load(Ordering::Relaxed)
-                    == ServerState::Active
-            })
+            .filter(|server_id| server_stats.get(server_id).unwrap().state == ServerState::Active)
            .count()
            .to_string(),
    ]));
@@ -275,15 +248,28 @@ where

    let mut res = BytesMut::new();
    res.put(row_description(&columns));
+    for (user_pool, pool) in get_all_pools() {
+        let def = HashMap::default();
+        let pool_stats = all_pool_stats
+            .get(&(user_pool.db.clone(), user_pool.user.clone()))
+            .unwrap_or(&def);

-    for ((_user_pool, _pool), pool_stats) in all_pool_stats {
+        let pool_config = &pool.settings;
        let mut row = vec![
-            pool_stats.database(),
-            pool_stats.user(),
-            pool_stats.pool_mode().to_string(),
+            user_pool.db.clone(),
+            user_pool.user.clone(),
+            pool_config.pool_mode.to_string(),
        ];
-        pool_stats.populate_row(&mut row);
-        pool_stats.clear_maxwait();
+        for column in &columns[3..columns.len()] {
+            let value = match column.0 {
+                "maxwait" => (pool_stats.get("maxwait_us").unwrap_or(&0) / 1_000_000).to_string(),
+                "maxwait_us" => {
+                    (pool_stats.get("maxwait_us").unwrap_or(&0) % 1_000_000).to_string()
+                }
+                _other_values => pool_stats.get(column.0).unwrap_or(&0).to_string(),
+            };
+            row.push(value);
+        }
        res.put(data_row(&row));
    }

@@ -414,7 +400,7 @@ where
    for (id, pool) in get_all_pools().iter() {
        for address in pool.get_addresses_from_host(host) {
            if !pool.is_banned(&address) {
-                pool.ban(&address, BanReason::AdminBan(duration_seconds), None);
+                pool.ban(&address, BanReason::AdminBan(duration_seconds), -1);
                res.put(data_row(&vec![
                    id.db.clone(),
                    id.user.clone(),
@@ -631,6 +617,7 @@ where
        ("avg_wait_time", DataType::Numeric),
    ];

+    let all_stats = get_address_stats();
    let mut res = BytesMut::new();
    res.put(row_description(&columns));

@@ -638,10 +625,15 @@ where
        for shard in 0..pool.shards() {
            for server in 0..pool.servers(shard) {
                let address = pool.address(shard, server);
+                let stats = match all_stats.get(&address.id) {
+                    Some(stats) => stats.clone(),
+                    None => HashMap::new(),
+                };

                let mut row = vec![address.name(), user_pool.db.clone(), user_pool.user.clone()];
-                let stats = address.stats.clone();
-                stats.populate_row(&mut row);
+                for column in &columns[3..] {
+                    row.push(stats.get(column.0).unwrap_or(&0).to_string());
+                }

                res.put(data_row(&row));
            }
@@ -681,16 +673,16 @@ where

    for (_, client) in new_map {
        let row = vec![
-            format!("{:#010X}", client.client_id()),
-            client.pool_name(),
-            client.username(),
-            client.application_name(),
-            client.state.load(Ordering::Relaxed).to_string(),
-            client.transaction_count.load(Ordering::Relaxed).to_string(),
-            client.query_count.load(Ordering::Relaxed).to_string(),
-            client.error_count.load(Ordering::Relaxed).to_string(),
+            format!("{:#010X}", client.client_id),
+            client.pool_name,
+            client.username,
+            client.application_name.clone(),
+            client.state.to_string(),
+            client.transaction_count.to_string(),
+            client.query_count.to_string(),
+            client.error_count.to_string(),
            Instant::now()
-                .duration_since(client.connect_time())
+                .duration_since(client.connect_time)
                .as_secs()
                .to_string(),
        ];
@@ -732,20 +724,19 @@ where
    res.put(row_description(&columns));

    for (_, server) in new_map {
-        let application_name = server.application_name.read();
        let row = vec![
-            format!("{:#010X}", server.server_id()),
-            server.pool_name(),
-            server.username(),
-            server.address_name(),
-            application_name.clone(),
-            server.state.load(Ordering::Relaxed).to_string(),
-            server.transaction_count.load(Ordering::Relaxed).to_string(),
-            server.query_count.load(Ordering::Relaxed).to_string(),
-            server.bytes_sent.load(Ordering::Relaxed).to_string(),
-            server.bytes_received.load(Ordering::Relaxed).to_string(),
+            format!("{:#010X}", server.server_id),
+            server.pool_name,
+            server.username,
+            server.address_name,
+            server.application_name,
+            server.state.to_string(),
+            server.transaction_count.to_string(),
+            server.query_count.to_string(),
+            server.bytes_sent.to_string(),
+            server.bytes_received.to_string(),
            Instant::now()
-                .duration_since(server.connect_time())
+                .duration_since(server.connect_time)
                .as_secs()
                .to_string(),
        ];
--- a/src/auth_passthrough.rs
+++ b/src/auth_passthrough.rs
@@ -1,132 +0,0 @@
-use crate::errors::Error;
-use crate::pool::ConnectionPool;
-use crate::server::Server;
-use log::debug;
-
-#[derive(Clone, Debug)]
-pub struct AuthPassthrough {
-    password: String,
-    query: String,
-    user: String,
-}
-
-impl AuthPassthrough {
-    /// Initializes an AuthPassthrough.
-    pub fn new(query: &str, user: &str, password: &str) -> Self {
-        AuthPassthrough {
-            password: password.to_string(),
-            query: query.to_string(),
-            user: user.to_string(),
-        }
-    }
-
-    /// Returns an AuthPassthrough given the pool configuration.
-    /// If any of required values is not set, None is returned.
-    pub fn from_pool_config(pool_config: &crate::config::Pool) -> Option<Self> {
-        if pool_config.is_auth_query_configured() {
-            return Some(AuthPassthrough::new(
-                pool_config.auth_query.as_ref().unwrap(),
-                pool_config.auth_query_user.as_ref().unwrap(),
-                pool_config.auth_query_password.as_ref().unwrap(),
-            ));
-        }
-
-        None
-    }
-
-    /// Returns an AuthPassthrough given the pool settings.
-    /// If any of required values is not set, None is returned.
-    pub fn from_pool_settings(pool_settings: &crate::pool::PoolSettings) -> Option<Self> {
-        let pool_config = crate::config::Pool {
-            auth_query: pool_settings.auth_query.clone(),
-            auth_query_password: pool_settings.auth_query_password.clone(),
-            auth_query_user: pool_settings.auth_query_user.clone(),
-            ..Default::default()
-        };
-
-        AuthPassthrough::from_pool_config(&pool_config)
-    }
-
-    /// Connects to server and executes auth_query for the specified address.
-    /// If the response is a row with two columns containing the username set in the address.
-    /// and its MD5 hash, the MD5 hash returned.
-    ///
-    /// Note that the query is executed, changing $1 with the name of the user
-    /// this is so we only hold in memory (and transfer) the least amount of 'sensitive' data.
-    /// Also, it is compatible with pgbouncer.
-    ///
-    /// # Arguments
-    ///
-    /// * `address` - An Address of the server we want to connect to. The username for the hash will be obtained from this value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use pgcat::auth_passthrough::AuthPassthrough;
-    /// use pgcat::config::Address;
-    /// let auth_passthrough = AuthPassthrough::new("SELECT * FROM public.user_lookup('$1');", "postgres", "postgres");
-    /// auth_passthrough.fetch_hash(&Address::default());
-    /// ```
-    ///
-    pub async fn fetch_hash(&self, address: &crate::config::Address) -> Result<String, Error> {
-        let auth_user = crate::config::User {
-            username: self.user.clone(),
-            password: Some(self.password.clone()),
-            server_username: None,
-            server_password: None,
-            pool_size: 1,
-            statement_timeout: 0,
-            pool_mode: None,
-        };
-
-        let user = &address.username;
-
-        debug!("Connecting to server to obtain auth hashes");
-
-        let auth_query = self.query.replace("$1", user);
-
-        match Server::exec_simple_query(address, &auth_user, &auth_query).await {
-            Ok(password_data) => {
-                if password_data.len() == 2 && password_data.first().unwrap() == user {
-                    if let Some(stripped_hash) = password_data
-                        .last()
-                        .unwrap()
-                        .to_string()
-                        .strip_prefix("md5") {
-                            Ok(stripped_hash.to_string())
-                        }
-                    else {
-                        Err(Error::AuthPassthroughError(
-                            "Obtained hash from auth_query does not seem to be in md5 format.".to_string(),
-                        ))
-                    }
-                } else {
-                    Err(Error::AuthPassthroughError(
-                        "Data obtained from query does not follow the scheme 'user','hash'."
-                            .to_string(),
-                    ))
-                 }
-            }
-            Err(err) => {
-                Err(Error::AuthPassthroughError(
-                    format!("Error trying to obtain password from auth_query, ignoring hash for user '{}'. Error: {:?}",
-                        user, err))
-                )
-            }
-        }
-    }
-}
-
-pub async fn refetch_auth_hash(pool: &ConnectionPool) -> Result<String, Error> {
-    let address = pool.address(0, 0);
-    if let Some(apt) = AuthPassthrough::from_pool_settings(&pool.settings) {
-        let hash = apt.fetch_hash(address).await?;
-
-        return Ok(hash);
-    }
-
-    Err(Error::ClientError(format!(
-        "Could not obtain hash for {{ username: {:?}, database: {:?} }}. Auth passthrough not enabled.",
-        address.username, address.database
-    )))
-}
--- a/src/client.rs
+++ b/src/client.rs
--- a/src/config.rs
+++ b/src/config.rs
@@ -15,7 +15,6 @@ use tokio::io::AsyncReadExt;
 use crate::errors::Error;
 use crate::pool::{ClientServerMap, ConnectionPool};
 use crate::sharding::ShardingFunction;
-use crate::stats::AddressStats;
 use crate::tls::{load_certs, load_keys};

 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -63,7 +62,7 @@ impl PartialEq<Role> for Option<Role> {
 }

 /// Address identifying a PostgreSQL server uniquely.
-#[derive(Clone, Debug)]
+#[derive(Clone, PartialEq, Hash, std::cmp::Eq, Debug)]
 pub struct Address {
    /// Unique ID per addressable Postgres server.
    pub id: usize,
@@ -97,9 +96,6 @@ pub struct Address {

    /// List of addresses to receive mirrored traffic.
    pub mirrors: Vec<Address>,
-
-    /// Address stats
-    pub stats: Arc<AddressStats>,
 }

 impl Default for Address {
@@ -116,46 +112,10 @@ impl Default for Address {
            username: String::from("username"),
            pool_name: String::from("pool_name"),
            mirrors: Vec::new(),
-            stats: Arc::new(AddressStats::default()),
        }
    }
 }

-// We need to implement PartialEq by ourselves so we skip stats in the comparison
-impl PartialEq for Address {
-    fn eq(&self, other: &Self) -> bool {
-        self.id == other.id
-            && self.host == other.host
-            && self.port == other.port
-            && self.shard == other.shard
-            && self.address_index == other.address_index
-            && self.replica_number == other.replica_number
-            && self.database == other.database
-            && self.role == other.role
-            && self.username == other.username
-            && self.pool_name == other.pool_name
-            && self.mirrors == other.mirrors
-    }
-}
-impl Eq for Address {}
-
-// We need to implement Hash by ourselves so we skip stats in the comparison
-impl Hash for Address {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.id.hash(state);
-        self.host.hash(state);
-        self.port.hash(state);
-        self.shard.hash(state);
-        self.address_index.hash(state);
-        self.replica_number.hash(state);
-        self.database.hash(state);
-        self.role.hash(state);
-        self.username.hash(state);
-        self.pool_name.hash(state);
-        self.mirrors.hash(state);
-    }
-}
-
 impl Address {
    /// Address name (aka database) used in `SHOW STATS`, `SHOW DATABASES`, and `SHOW POOLS`.
    pub fn name(&self) -> String {
@@ -177,11 +137,8 @@ impl Address {
 #[derive(Clone, PartialEq, Hash, Eq, Serialize, Deserialize, Debug)]
 pub struct User {
    pub username: String,
-    pub password: Option<String>,
-    pub server_username: Option<String>,
-    pub server_password: Option<String>,
+    pub password: String,
    pub pool_size: u32,
-    pub pool_mode: Option<PoolMode>,
    #[serde(default)] // 0
    pub statement_timeout: u64,
 }
@@ -190,12 +147,9 @@ impl Default for User {
    fn default() -> User {
        User {
            username: String::from("postgres"),
-            password: None,
-            server_username: None,
-            server_password: None,
+            password: String::new(),
            pool_size: 15,
            statement_timeout: 0,
-            pool_mode: None,
        }
    }
 }
@@ -207,7 +161,7 @@ pub struct General {
    pub host: String,

    #[serde(default = "General::default_port")]
-    pub port: u16,
+    pub port: i16,

    pub enable_prometheus_exporter: Option<bool>,
    pub prometheus_exporter_port: i16,
@@ -243,23 +197,16 @@ pub struct General {
    #[serde(default = "General::default_ban_time")]
    pub ban_time: i64,

-    #[serde(default = "General::default_idle_client_in_transaction_timeout")]
-    pub idle_client_in_transaction_timeout: u64,
-
    #[serde(default = "General::default_worker_threads")]
    pub worker_threads: usize,

-    #[serde(default)] // None
-    pub autoreload: Option<u64>,
+    #[serde(default)] // False
+    pub autoreload: bool,

    pub tls_certificate: Option<String>,
    pub tls_private_key: Option<String>,
    pub admin_username: String,
    pub admin_password: String,
-
-    pub auth_query: Option<String>,
-    pub auth_query_user: Option<String>,
-    pub auth_query_password: Option<String>,
 }

 impl General {
@@ -267,7 +214,7 @@ impl General {
        "0.0.0.0".into()
    }

-    pub fn default_port() -> u16 {
+    pub fn default_port() -> i16 {
        5432
    }

@@ -277,7 +224,7 @@ impl General {

    // These keepalive defaults should detect a dead connection within 30 seconds.
    // Tokio defaults to disabling keepalives which keeps dead connections around indefinitely.
-    // This can lead to permanent server pool exhaustion
+    // This can lead to permenant server pool exhaustion
    pub fn default_tcp_keepalives_idle() -> u64 {
        5 // 5 seconds
    }
@@ -313,10 +260,6 @@ impl General {
    pub fn default_worker_threads() -> usize {
        4
    }
-
-    pub fn default_idle_client_in_transaction_timeout() -> u64 {
-        0
-    }
 }

 impl Default for General {
@@ -333,20 +276,16 @@ impl Default for General {
            healthcheck_delay: Self::default_healthcheck_delay(),
            ban_time: Self::default_ban_time(),
            worker_threads: Self::default_worker_threads(),
-            idle_client_in_transaction_timeout: Self::default_idle_client_in_transaction_timeout(),
            tcp_keepalives_idle: Self::default_tcp_keepalives_idle(),
            tcp_keepalives_count: Self::default_tcp_keepalives_count(),
            tcp_keepalives_interval: Self::default_tcp_keepalives_interval(),
            log_client_connections: false,
            log_client_disconnections: false,
-            autoreload: None,
+            autoreload: false,
            tls_certificate: None,
            tls_private_key: None,
            admin_username: String::from("admin"),
            admin_password: String::from("admin"),
-            auth_query: None,
-            auth_query_user: None,
-            auth_query_password: None,
        }
    }
 }
@@ -362,7 +301,6 @@ pub enum PoolMode {
    #[serde(alias = "session", alias = "Session")]
    Session,
 }
-
 impl ToString for PoolMode {
    fn to_string(&self) -> String {
        match *self {
@@ -420,13 +358,9 @@ pub struct Pool {
    pub shard_id_regex: Option<String>,
    pub regex_search_limit: Option<usize>,

-    pub auth_query: Option<String>,
-    pub auth_query_user: Option<String>,
-    pub auth_query_password: Option<String>,
-
    pub shards: BTreeMap<String, Shard>,
    pub users: BTreeMap<String, User>,
-    // Note, don't put simple fields below these configs. There's a compatibility issue with TOML that makes it
+    // Note, don't put simple fields below these configs. There's a compatability issue with TOML that makes it
    // incompatible to have simple fields in TOML after complex objects. See
    // https://users.rust-lang.org/t/why-toml-to-string-get-error-valueaftertable/85903
 }
@@ -438,12 +372,6 @@ impl Pool {
        s.finish()
    }

-    pub fn is_auth_query_configured(&self) -> bool {
-        self.auth_query_password.is_some()
-            && self.auth_query_user.is_some()
-            && self.auth_query_password.is_some()
-    }
-
    pub fn default_pool_mode() -> PoolMode {
        PoolMode::Transaction
    }
@@ -536,9 +464,6 @@ impl Default for Pool {
            sharding_key_regex: None,
            shard_id_regex: None,
            regex_search_limit: Some(1000),
-            auth_query: None,
-            auth_query_user: None,
-            auth_query_password: None,
        }
    }
 }
@@ -639,31 +564,9 @@ pub struct Config {
 }

 impl Config {
-    pub fn is_auth_query_configured(&self) -> bool {
-        self.pools
-            .iter()
-            .any(|(_name, pool)| pool.is_auth_query_configured())
-    }
-
    pub fn default_path() -> String {
        String::from("pgcat.toml")
    }
-
-    pub fn fill_up_auth_query_config(&mut self) {
-        for (_name, pool) in self.pools.iter_mut() {
-            if pool.auth_query.is_none() {
-                pool.auth_query = self.general.auth_query.clone();
-            }
-
-            if pool.auth_query_user.is_none() {
-                pool.auth_query_user = self.general.auth_query_user.clone();
-            }
-
-            if pool.auth_query_password.is_none() {
-                pool.auth_query_password = self.general.auth_query_password.clone();
-            }
-        }
-    }
 }

 impl Default for Config {
@@ -752,13 +655,6 @@ impl From<&Config> for std::collections::HashMap<String, String> {
                config.general.healthcheck_delay.to_string(),
            ),
            ("ban_time".to_string(), config.general.ban_time.to_string()),
-            (
-                "idle_client_in_transaction_timeout".to_string(),
-                config
-                    .general
-                    .idle_client_in_transaction_timeout
-                    .to_string(),
-            ),
        ];

        r.append(&mut static_settings);
@@ -770,10 +666,6 @@ impl Config {
    /// Print current configuration.
    pub fn show(&self) {
        info!("Ban time: {}s", self.general.ban_time);
-        info!(
-            "Idle client in transaction timeout: {}ms",
-            self.general.idle_client_in_transaction_timeout
-        );
        info!("Worker threads: {}", self.general.worker_threads);
        info!(
            "Healthcheck timeout: {}ms",
@@ -823,9 +715,8 @@ impl Config {
                    .to_string()
            );
            info!(
-                "[pool: {}] Default pool mode: {}",
-                pool_name,
-                pool_config.pool_mode.to_string()
+                "[pool: {}] Pool mode: {:?}",
+                pool_name, pool_config.pool_mode
            );
            info!(
                "[pool: {}] Load Balancing mode: {:?}",
@@ -876,50 +767,12 @@ impl Config {
                info!(
                    "[pool: {}][user: {}] Statement timeout: {}",
                    pool_name, user.1.username, user.1.statement_timeout
-                );
-                info!(
-                    "[pool: {}][user: {}] Pool mode: {}",
-                    pool_name,
-                    user.1.username,
-                    match user.1.pool_mode {
-                        Some(pool_mode) => pool_mode.to_string(),
-                        None => pool_config.pool_mode.to_string(),
-                    }
-                );
+                )
            }
        }
    }

    pub fn validate(&mut self) -> Result<(), Error> {
-        // Validation for auth_query feature
-        if self.general.auth_query.is_some()
-            && (self.general.auth_query_user.is_none()
-                || self.general.auth_query_password.is_none())
-        {
-            error!("If auth_query is specified, you need to provide a value for `auth_query_user`, `auth_query_password`");
-            return Err(Error::BadConfig);
-        }
-
-        for (name, pool) in self.pools.iter() {
-            if pool.auth_query.is_some()
-                && (pool.auth_query_user.is_none() || pool.auth_query_password.is_none())
-            {
-                error!("Error in pool {{ {} }}. If auth_query is specified, you need to provide a value for `auth_query_user`, `auth_query_password`", name);
-                return Err(Error::BadConfig);
-            }
-
-            for (_name, user_data) in pool.users.iter() {
-                if (pool.auth_query.is_none()
-                    || pool.auth_query_password.is_none()
-                    || pool.auth_query_user.is_none())
-                    && user_data.password.is_none()
-                {
-                    error!("Error in pool {{ {} }}. You have to specify a user password for every pool if auth_query is not specified", name);
-                    return Err(Error::BadConfig);
-                }
-            }
-        }
-
        // Validate TLS!
        match self.general.tls_certificate.clone() {
            Some(tls_certificate) => {
@@ -966,12 +819,6 @@ pub fn get_config() -> Config {
    (*(*CONFIG.load())).clone()
 }

-pub fn get_idle_client_in_transaction_timeout() -> u64 {
-    (*(*CONFIG.load()))
-        .general
-        .idle_client_in_transaction_timeout
-}
-
 /// Parse the configuration file located at the path.
 pub async fn parse(path: &str) -> Result<(), Error> {
    let mut contents = String::new();
@@ -999,7 +846,6 @@ pub async fn parse(path: &str) -> Result<(), Error> {
        }
    };

-    config.fill_up_auth_query_config();
    config.validate()?;

    config.path = path.to_string();
@@ -1043,7 +889,6 @@ mod test {
        assert_eq!(get_config().path, "pgcat.toml".to_string());

        assert_eq!(get_config().general.ban_time, 60);
-        assert_eq!(get_config().general.idle_client_in_transaction_timeout, 0);
        assert_eq!(get_config().general.idle_timeout, 30000);
        assert_eq!(get_config().pools.len(), 2);
        assert_eq!(get_config().pools["sharded_db"].shards.len(), 3);
@@ -1069,10 +914,7 @@ mod test {
            "sharding_user"
        );
        assert_eq!(
-            get_config().pools["sharded_db"].users["1"]
-                .password
-                .as_ref()
-                .unwrap(),
+            get_config().pools["sharded_db"].users["1"].password,
            "other_user"
        );
        assert_eq!(get_config().pools["sharded_db"].users["1"].pool_size, 21);
@@ -1097,16 +939,10 @@ mod test {
            "simple_user"
        );
        assert_eq!(
-            get_config().pools["simple_db"].users["0"]
-                .password
-                .as_ref()
-                .unwrap(),
+            get_config().pools["simple_db"].users["0"].password,
            "simple_user"
        );
        assert_eq!(get_config().pools["simple_db"].users["0"].pool_size, 5);
-        assert_eq!(get_config().general.auth_query, None);
-        assert_eq!(get_config().general.auth_query_user, None);
-        assert_eq!(get_config().general.auth_query_password, None);
    }

    #[tokio::test]
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -1,19 +1,13 @@
-//! Errors.
+/// Errors.

 /// Various errors.
 #[derive(Debug, PartialEq)]
 pub enum Error {
    SocketError(String),
-    ClientSocketError(String, ClientIdentifier),
-    ClientGeneralError(String, ClientIdentifier),
-    ClientAuthImpossible(String),
-    ClientAuthPassthroughError(String, ClientIdentifier),
    ClientBadStartup,
    ProtocolSyncError(String),
    BadQuery(String),
    ServerError,
-    ServerStartupError(String, ServerIdentifier),
-    ServerAuthError(String, ServerIdentifier),
    BadConfig,
    AllServersDown,
    ClientError(String),
@@ -21,100 +15,4 @@ pub enum Error {
    StatementTimeout,
    ShuttingDown,
    ParseBytesError(String),
-    AuthError(String),
-    AuthPassthroughError(String),
-}
-
-#[derive(Clone, PartialEq, Debug)]
-pub struct ClientIdentifier {
-    pub application_name: String,
-    pub username: String,
-    pub pool_name: String,
-}
-
-impl ClientIdentifier {
-    pub fn new(application_name: &str, username: &str, pool_name: &str) -> ClientIdentifier {
-        ClientIdentifier {
-            application_name: application_name.into(),
-            username: username.into(),
-            pool_name: pool_name.into(),
-        }
-    }
-}
-
-impl std::fmt::Display for ClientIdentifier {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(
-            f,
-            "{{ application_name: {}, username: {}, pool_name: {} }}",
-            self.application_name, self.username, self.pool_name
-        )
-    }
-}
-
-#[derive(Clone, PartialEq, Debug)]
-pub struct ServerIdentifier {
-    pub username: String,
-    pub database: String,
-}
-
-impl ServerIdentifier {
-    pub fn new(username: &str, database: &str) -> ServerIdentifier {
-        ServerIdentifier {
-            username: username.into(),
-            database: database.into(),
-        }
-    }
-}
-
-impl std::fmt::Display for ServerIdentifier {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(
-            f,
-            "{{ username: {}, database: {} }}",
-            self.username, self.database
-        )
-    }
-}
-
-impl std::fmt::Display for Error {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match &self {
-            &Error::ClientSocketError(error, client_identifier) => write!(
-                f,
-                "Error reading {} from client {}",
-                error, client_identifier
-            ),
-            &Error::ClientGeneralError(error, client_identifier) => {
-                write!(f, "{} {}", error, client_identifier)
-            }
-            &Error::ClientAuthImpossible(username) => write!(
-                f,
-                "Client auth not possible, \
-                no cleartext password set for username: {} \
-                in config and auth passthrough (query_auth) \
-                is not set up.",
-                username
-            ),
-            &Error::ClientAuthPassthroughError(error, client_identifier) => write!(
-                f,
-                "No cleartext password set, \
-                    and no auth passthrough could not \
-                    obtain the hash from server for {}, \
-                    the error was: {}",
-                client_identifier, error
-            ),
-            &Error::ServerStartupError(error, server_identifier) => write!(
-                f,
-                "Error reading {} on server startup {}",
-                error, server_identifier,
-            ),
-            &Error::ServerAuthError(error, server_identifier) => {
-                write!(f, "{} for {}", error, server_identifier,)
-            }
-
-            // The rest can use Debug.
-            err => write!(f, "{:?}", err),
-        }
-    }
 }
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,3 @@
-pub mod auth_passthrough;
 pub mod config;
 pub mod constants;
 pub mod errors;
--- a/src/main.rs
+++ b/src/main.rs
@@ -61,7 +61,6 @@ use std::sync::Arc;
 use tokio::sync::broadcast;

 mod admin;
-mod auth_passthrough;
 mod client;
 mod config;
 mod constants;
@@ -79,7 +78,6 @@ mod stats;
 mod tls;

 use crate::config::{get_config, reload_config, VERSION};
-use crate::messages::configure_socket;
 use crate::pool::{ClientServerMap, ConnectionPool};
 use crate::prometheus::start_metric_server;
 use crate::stats::{Collector, Reporter, REPORTER};
@@ -164,7 +162,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
        let client_server_map: ClientServerMap = Arc::new(Mutex::new(HashMap::new()));

        // Statistics reporting.
-        REPORTER.store(Arc::new(Reporter::default()));
+        let (stats_tx, stats_rx) = mpsc::channel(500_000);
+        REPORTER.store(Arc::new(Reporter::new(stats_tx.clone())));

        // Connection pool that allows to query all shards and replicas.
        match ConnectionPool::from_config(client_server_map.clone()).await {
@@ -176,23 +175,20 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
        };

        tokio::task::spawn(async move {
-            let mut stats_collector = Collector::default();
+            let mut stats_collector = Collector::new(stats_rx, stats_tx.clone());
            stats_collector.collect().await;
        });

-        info!("Config autoreloader: {}", match config.general.autoreload {
-            Some(interval) => format!("{} ms", interval),
-            None => "disabled".into(),
-        });
+        info!("Config autoreloader: {}", config.general.autoreload);

-        if let Some(interval) = config.general.autoreload {
-            let mut autoreload_interval = tokio::time::interval(tokio::time::Duration::from_millis(interval));
-            let autoreload_client_server_map = client_server_map.clone();
+        let mut autoreload_interval = tokio::time::interval(tokio::time::Duration::from_millis(15_000));
+        let autoreload_client_server_map = client_server_map.clone();

-            tokio::task::spawn(async move {
-                loop {
-                    autoreload_interval.tick().await;
-                    debug!("Automatically reloading config");
+        tokio::task::spawn(async move {
+            loop {
+                autoreload_interval.tick().await;
+                if config.general.autoreload {
+                    info!("Automatically reloading config");

                    if let Ok(changed) = reload_config(autoreload_client_server_map.clone()).await {
                        if changed {
@@ -200,10 +196,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                        }
                    };
                }
-            });
-        };
-
-
+            }
+        });

        #[cfg(windows)]
        let mut term_signal = win_signal::ctrl_close().unwrap();
@@ -288,9 +282,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                    let drain_tx = drain_tx.clone();
                    let client_server_map = client_server_map.clone();

-                    let tls_certificate = get_config().general.tls_certificate.clone();
-
-                    configure_socket(&socket);
+                    let tls_certificate = config.general.tls_certificate.clone();

                    tokio::task::spawn(async move {
                        let start = chrono::offset::Utc::now().naive_utc();
@@ -301,7 +293,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                            shutdown_rx,
                            drain_tx,
                            admin_only,
-                            tls_certificate,
+                            tls_certificate.clone(),
                            config.general.log_client_connections,
                        )
                        .await
@@ -309,7 +301,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                            Ok(()) => {
                                let duration = chrono::offset::Utc::now().naive_utc() - start;

-                                if get_config().general.log_client_disconnections {
+                                if config.general.log_client_disconnections {
                                    info!(
                                        "Client {:?} disconnected, session duration: {}",
                                        addr,
--- a/src/messages.rs
+++ b/src/messages.rs
@@ -213,13 +213,7 @@ pub fn md5_hash_password(user: &str, password: &str, salt: &[u8]) -> Vec<u8> {
    let output = md5.finalize_reset();

    // Second pass
-    md5_hash_second_pass(&(format!("{:x}", output)), salt)
-}
-
-pub fn md5_hash_second_pass(hash: &str, salt: &[u8]) -> Vec<u8> {
-    let mut md5 = Md5::new();
-    // Second pass
-    md5.update(hash);
+    md5.update(format!("{:x}", output));
    md5.update(salt);

    let mut password = format!("md5{:x}", md5.finalize())
@@ -253,20 +247,6 @@ where
    write_all(stream, message).await
 }

-pub async fn md5_password_with_hash<S>(stream: &mut S, hash: &str, salt: &[u8]) -> Result<(), Error>
-where
-    S: tokio::io::AsyncWrite + std::marker::Unpin,
-{
-    let password = md5_hash_second_pass(hash, salt);
-    let mut message = BytesMut::with_capacity(password.len() as usize + 5);
-
-    message.put_u8(b'p');
-    message.put_i32(password.len() as i32 + 4);
-    message.put_slice(&password[..]);
-
-    write_all(stream, message).await
-}
-
 /// Implements a response to our custom `SET SHARDING KEY`
 /// and `SET SERVER ROLE` commands.
 /// This tells the client we're ready for the next query.
@@ -404,7 +384,7 @@ pub fn row_description(columns: &Vec<(&str, DataType)>) -> BytesMut {
    let mut res = BytesMut::new();
    let mut row_desc = BytesMut::new();

-    // how many columns we are storing
+    // how many colums we are storing
    row_desc.put_i16(columns.len() as i16);

    for (name, data_type) in columns {
--- a/src/mirrors.rs
+++ b/src/mirrors.rs
@@ -1,14 +1,11 @@
-use std::sync::Arc;
-
 /// A mirrored PostgreSQL client.
 /// Packets arrive to us through a channel from the main client and we send them to the server.
 use bb8::Pool;
 use bytes::{Bytes, BytesMut};
-use parking_lot::RwLock;

 use crate::config::{get_config, Address, Role, User};
-use crate::pool::{ClientServerMap, PoolIdentifier, ServerPool};
-use crate::stats::PoolStats;
+use crate::pool::{ClientServerMap, ServerPool};
+use crate::stats::get_reporter;
 use log::{error, info, trace, warn};
 use tokio::sync::mpsc::{channel, Receiver, Sender};

@@ -24,25 +21,20 @@ impl MirroredClient {
    async fn create_pool(&self) -> Pool<ServerPool> {
        let config = get_config();
        let default = std::time::Duration::from_millis(10_000).as_millis() as u64;
-        let (connection_timeout, idle_timeout, cfg) =
-            match config.pools.get(&self.address.pool_name) {
-                Some(cfg) => (
-                    cfg.connect_timeout.unwrap_or(default),
-                    cfg.idle_timeout.unwrap_or(default),
-                    cfg.clone(),
-                ),
-                None => (default, default, crate::config::Pool::default()),
-            };
-
-        let identifier = PoolIdentifier::new(&self.database, &self.user.username);
+        let (connection_timeout, idle_timeout) = match config.pools.get(&self.address.pool_name) {
+            Some(cfg) => (
+                cfg.connect_timeout.unwrap_or(default),
+                cfg.idle_timeout.unwrap_or(default),
+            ),
+            None => (default, default),
+        };

        let manager = ServerPool::new(
            self.address.clone(),
            self.user.clone(),
            self.database.as_str(),
            ClientServerMap::default(),
-            Arc::new(PoolStats::new(identifier, cfg.clone())),
-            Arc::new(RwLock::new(None)),
+            get_reporter(),
        );

        Pool::builder()
--- a/src/multi_logger.rs
+++ b/src/multi_logger.rs
@@ -17,7 +17,7 @@ use log::{Level, Log, Metadata, Record, SetLoggerError};
 //
 // So to summarize, if no `STDOUT_LOG` env var is present, the logger is the default logger. If `STDOUT_LOG` is set, everything
 // but errors, that matches the log level set in the `STDOUT_LOG` env var is sent to stdout. You can have also some esoteric configuration
-// where you set `RUST_LOG=debug` and `STDOUT_LOG=info`, in here, errors will go to stderr, warns and infos to stdout and debugs to stderr.
+// where you set `RUST_LOG=debug` and `STDOUT_LOG=info`, in here, erros will go to stderr, warns and infos to stdout and debugs to stderr.
 //
 pub struct MultiLogger {
    stderr_logger: env_logger::Logger,
--- a/src/pool.rs
+++ b/src/pool.rs
@@ -20,10 +20,9 @@ use tokio::sync::Notify;
 use crate::config::{get_config, Address, General, LoadBalancingMode, PoolMode, Role, User};
 use crate::errors::Error;

-use crate::auth_passthrough::AuthPassthrough;
 use crate::server::Server;
 use crate::sharding::ShardingFunction;
-use crate::stats::{AddressStats, ClientStats, PoolStats, ServerStats};
+use crate::stats::{get_reporter, Reporter};

 pub type ProcessId = i32;
 pub type SecretKey = i32;
@@ -52,7 +51,7 @@ pub enum BanReason {

 /// An identifier for a PgCat pool,
 /// a database visible to clients.
-#[derive(Hash, Debug, Clone, PartialEq, Eq, Default)]
+#[derive(Hash, Debug, Clone, PartialEq, Eq)]
 pub struct PoolIdentifier {
    // The name of the database clients want to connect to.
    pub db: String,
@@ -124,11 +123,6 @@ pub struct PoolSettings {

    // Limit how much of each query is searched for a potential shard regex match
    pub regex_search_limit: usize,
-
-    // Auth query parameters
-    pub auth_query: Option<String>,
-    pub auth_query_user: Option<String>,
-    pub auth_query_password: Option<String>,
 }

 impl Default for PoolSettings {
@@ -149,9 +143,6 @@ impl Default for PoolSettings {
            sharding_key_regex: None,
            shard_id_regex: None,
            regex_search_limit: 1000,
-            auth_query: None,
-            auth_query_user: None,
-            auth_query_password: None,
        }
    }
 }
@@ -170,6 +161,10 @@ pub struct ConnectionPool {
    /// that should not be queried.
    banlist: BanList,

+    /// The statistics aggregator runs in a separate task
+    /// and receives stats from clients, servers, and the pool.
+    stats: Reporter,
+
    /// The server information (K messages) have to be passed to the
    /// clients on startup. We pre-connect to all shards and replicas
    /// on pool creation and save the K messages here.
@@ -190,11 +185,6 @@ pub struct ConnectionPool {
    /// If the pool has been paused or not.
    paused: Arc<AtomicBool>,
    paused_waiter: Arc<Notify>,
-
-    pub stats: Arc<PoolStats>,
-
-    /// AuthInfo
-    pub auth_hash: Arc<RwLock<Option<String>>>,
 }

 impl ConnectionPool {
@@ -211,7 +201,6 @@ impl ConnectionPool {
            // There is one pool per database/user pair.
            for user in pool_config.users.values() {
                let old_pool_ref = get_pool(pool_name, &user.username);
-                let identifier = PoolIdentifier::new(pool_name, &user.username);

                match old_pool_ref {
                    Some(pool) => {
@@ -222,7 +211,10 @@ impl ConnectionPool {
                                "[pool: {}][user: {}] has not changed",
                                pool_name, user.username
                            );
-                            new_pools.insert(identifier.clone(), pool.clone());
+                            new_pools.insert(
+                                PoolIdentifier::new(pool_name, &user.username),
+                                pool.clone(),
+                            );
                            continue;
                        }
                    }
@@ -242,14 +234,9 @@ impl ConnectionPool {
                    .clone()
                    .into_keys()
                    .collect::<Vec<String>>();
-                let pool_stats = Arc::new(PoolStats::new(identifier, pool_config.clone()));
-
-                // Allow the pool to be seen in statistics
-                pool_stats.register(pool_stats.clone());

                // Sort by shard number to ensure consistency.
                shard_ids.sort_by_key(|k| k.parse::<i64>().unwrap());
-                let pool_auth_hash: Arc<RwLock<Option<String>>> = Arc::new(RwLock::new(None));

                for shard_idx in &shard_ids {
                    let shard = &pool_config.shards[shard_idx];
@@ -279,7 +266,6 @@ impl ConnectionPool {
                                    username: user.username.clone(),
                                    pool_name: pool_name.clone(),
                                    mirrors: vec![],
-                                    stats: Arc::new(AddressStats::default()),
                                });
                                address_id += 1;
                            }
@@ -297,7 +283,6 @@ impl ConnectionPool {
                            username: user.username.clone(),
                            pool_name: pool_name.clone(),
                            mirrors: mirror_addresses,
-                            stats: Arc::new(AddressStats::default()),
                        };

                        address_id += 1;
@@ -306,35 +291,12 @@ impl ConnectionPool {
                            replica_number += 1;
                        }

-                        // We assume every server in the pool share user/passwords
-                        let auth_passthrough = AuthPassthrough::from_pool_config(pool_config);
-
-                        if let Some(apt) = &auth_passthrough {
-                            match apt.fetch_hash(&address).await {
-				Ok(ok) => {
-				    if let Some(ref pool_auth_hash_value) = *(pool_auth_hash.read()) {
-					if ok != *pool_auth_hash_value {
-					    warn!("Hash is not the same across shards of the same pool, client auth will \
-						   be done using last obtained hash. Server: {}:{}, Database: {}", server.host, server.port, shard.database);
-					}
-				    }
-				    debug!("Hash obtained for {:?}", address);
-				    {
-					let mut pool_auth_hash = pool_auth_hash.write();
-					*pool_auth_hash = Some(ok.clone());
-				    }
-				},
-				Err(err) => warn!("Could not obtain password hashes using auth_query config, ignoring. Error: {:?}", err),
-			    }
-                        }
-
                        let manager = ServerPool::new(
                            address.clone(),
                            user.clone(),
                            &shard.database,
                            client_server_map.clone(),
-                            pool_stats.clone(),
-                            pool_auth_hash.clone(),
+                            get_reporter(),
                        );

                        let connect_timeout = match pool_config.connect_timeout {
@@ -366,26 +328,16 @@ impl ConnectionPool {
                }

                assert_eq!(shards.len(), addresses.len());
-                if let Some(ref _auth_hash) = *(pool_auth_hash.clone().read()) {
-                    info!(
-                        "Auth hash obtained from query_auth for pool {{ name: {}, user: {} }}",
-                        pool_name, user.username
-                    );
-                }

                let pool = ConnectionPool {
                    databases: shards,
-                    stats: pool_stats,
                    addresses,
                    banlist: Arc::new(RwLock::new(banlist)),
+                    stats: get_reporter(),
                    config_hash: new_pool_hash_value,
                    server_info: Arc::new(RwLock::new(BytesMut::new())),
-                    auth_hash: pool_auth_hash,
                    settings: PoolSettings {
-                        pool_mode: match user.pool_mode {
-                            Some(pool_mode) => pool_mode,
-                            None => pool_config.pool_mode,
-                        },
+                        pool_mode: pool_config.pool_mode,
                        load_balancing_mode: pool_config.load_balancing_mode,
                        // shards: pool_config.shards.clone(),
                        shards: shard_ids.len(),
@@ -412,9 +364,6 @@ impl ConnectionPool {
                            .clone()
                            .map(|regex| Regex::new(regex.as_str()).unwrap()),
                        regex_search_limit: pool_config.regex_search_limit.unwrap_or(1000),
-                        auth_query: pool_config.auth_query.clone(),
-                        auth_query_user: pool_config.auth_query_user.clone(),
-                        auth_query_password: pool_config.auth_query_password.clone(),
                    },
                    validated: Arc::new(AtomicBool::new(false)),
                    paused: Arc::new(AtomicBool::new(false)),
@@ -438,8 +387,7 @@ impl ConnectionPool {
        Ok(())
    }

-    /// Connect to all shards, grab server information, and possibly
-    /// passwords to use in client auth.
+    /// Connect to all shards and grab server information.
    /// Return server information we will pass to the clients
    /// when they connect.
    /// This also warms up the pool for clients that connect when
@@ -528,9 +476,9 @@ impl ConnectionPool {
    /// Get a connection from the pool.
    pub async fn get(
        &self,
-        shard: usize,               // shard number
-        role: Option<Role>,         // primary or replica
-        client_stats: &ClientStats, // client id
+        shard: usize,           // shard number
+        role: Option<Role>,     // primary or replica
+        client_process_id: i32, // client id
    ) -> Result<(PooledConnection<'_, ServerPool>, Address), Error> {
        let mut candidates: Vec<&Address> = self.addresses[shard]
            .iter()
@@ -569,7 +517,7 @@ impl ConnectionPool {

            // Indicate we're waiting on a server connection from a pool.
            let now = Instant::now();
-            client_stats.waiting();
+            self.stats.client_waiting(client_process_id);

            // Check if we can connect
            let mut conn = match self.databases[address.shard][address.address_index]
@@ -579,10 +527,9 @@ impl ConnectionPool {
                Ok(conn) => conn,
                Err(err) => {
                    error!("Banning instance {:?}, error: {:?}", address, err);
-                    self.ban(address, BanReason::FailedCheckout, Some(client_stats));
-                    address.stats.error();
-                    client_stats.idle();
-                    client_stats.checkout_error();
+                    self.ban(address, BanReason::FailedCheckout, client_process_id);
+                    self.stats
+                        .client_checkout_error(client_process_id, address.id);
                    continue;
                }
            };
@@ -599,18 +546,18 @@ impl ConnectionPool {
            // since we last checked the server is ok.
            // Health checks are pretty expensive.
            if !require_healthcheck {
-                let checkout_time: u64 = now.elapsed().as_micros() as u64;
-                client_stats.checkout_time(checkout_time);
-                server
-                    .stats()
-                    .checkout_time(checkout_time, client_stats.application_name());
-                server.stats().active(client_stats.application_name());
-
+                self.stats.checkout_time(
+                    now.elapsed().as_micros(),
+                    client_process_id,
+                    server.server_id(),
+                );
+                self.stats
+                    .server_active(client_process_id, server.server_id());
                return Ok((conn, address.clone()));
            }

            if self
-                .run_health_check(address, server, now, client_stats)
+                .run_health_check(address, server, now, client_process_id)
                .await
            {
                return Ok((conn, address.clone()));
@@ -618,6 +565,7 @@ impl ConnectionPool {
                continue;
            }
        }
+
        Err(Error::AllServersDown)
    }

@@ -626,11 +574,11 @@ impl ConnectionPool {
        address: &Address,
        server: &mut Server,
        start: Instant,
-        client_info: &ClientStats,
+        client_process_id: i32,
    ) -> bool {
        debug!("Running health check on server {:?}", address);

-        server.stats().tested();
+        self.stats.server_tested(server.server_id());

        match tokio::time::timeout(
            tokio::time::Duration::from_millis(self.settings.healthcheck_timeout),
@@ -641,13 +589,13 @@ impl ConnectionPool {
            // Check if health check succeeded.
            Ok(res) => match res {
                Ok(_) => {
-                    let checkout_time: u64 = start.elapsed().as_micros() as u64;
-                    client_info.checkout_time(checkout_time);
-                    server
-                        .stats()
-                        .checkout_time(checkout_time, client_info.application_name());
-                    server.stats().active(client_info.application_name());
-
+                    self.stats.checkout_time(
+                        start.elapsed().as_micros(),
+                        client_process_id,
+                        server.server_id(),
+                    );
+                    self.stats
+                        .server_active(client_process_id, server.server_id());
                    return true;
                }

@@ -672,14 +620,14 @@ impl ConnectionPool {
        // Don't leave a bad connection in the pool.
        server.mark_bad();

-        self.ban(&address, BanReason::FailedHealthCheck, Some(client_info));
+        self.ban(&address, BanReason::FailedHealthCheck, client_process_id);
        return false;
    }

    /// Ban an address (i.e. replica). It no longer will serve
    /// traffic for any new transactions. Existing transactions on that replica
    /// will finish successfully or error out to the clients.
-    pub fn ban(&self, address: &Address, reason: BanReason, client_info: Option<&ClientStats>) {
+    pub fn ban(&self, address: &Address, reason: BanReason, client_id: i32) {
        // Primary can never be banned
        if address.role == Role::Primary {
            return;
@@ -688,10 +636,7 @@ impl ConnectionPool {
        let now = chrono::offset::Utc::now().naive_utc();
        let mut guard = self.banlist.write();
        error!("Banning {:?}", address);
-        if let Some(client_info) = client_info {
-            client_info.ban_error();
-            address.stats.error();
-        }
+        self.stats.client_ban_error(client_id, address.id);
        guard[address.shard].insert(address.clone(), (reason, now));
    }

@@ -777,7 +722,6 @@ impl ConnectionPool {
        self.databases.len()
    }

-    /// Retrieve all bans for all servers.
    pub fn get_bans(&self) -> Vec<(Address, (BanReason, NaiveDateTime))> {
        let mut bans: Vec<(Address, (BanReason, NaiveDateTime))> = Vec::new();
        let guard = self.banlist.read();
@@ -789,7 +733,7 @@ impl ConnectionPool {
        return bans;
    }

-    /// Get the address from the host url.
+    /// Get the address from the host url
    pub fn get_addresses_from_host(&self, host: &str) -> Vec<Address> {
        let mut addresses = Vec::new();
        for shard in 0..self.shards() {
@@ -828,13 +772,10 @@ impl ConnectionPool {
        &self.addresses[shard][server]
    }

-    /// Get server settings retrieved at connection setup.
    pub fn server_info(&self) -> BytesMut {
        self.server_info.read().clone()
    }

-    /// Calculate how many used connections in the pool
-    /// for the given server.
    fn busy_connection_count(&self, address: &Address) -> u32 {
        let state = self.pool_state(address.shard, address.address_index);
        let idle = state.idle_connections;
@@ -856,8 +797,7 @@ pub struct ServerPool {
    user: User,
    database: String,
    client_server_map: ClientServerMap,
-    stats: Arc<PoolStats>,
-    auth_hash: Arc<RwLock<Option<String>>>,
+    stats: Reporter,
 }

 impl ServerPool {
@@ -866,16 +806,14 @@ impl ServerPool {
        user: User,
        database: &str,
        client_server_map: ClientServerMap,
-        stats: Arc<PoolStats>,
-        auth_hash: Arc<RwLock<Option<String>>>,
+        stats: Reporter,
    ) -> ServerPool {
        ServerPool {
            address,
-            user: user.clone(),
+            user,
            database: database.to_string(),
            client_server_map,
            stats,
-            auth_hash,
        }
    }
 }
@@ -888,32 +826,34 @@ impl ManageConnection for ServerPool {
    /// Attempts to create a new connection.
    async fn connect(&self) -> Result<Self::Connection, Self::Error> {
        info!("Creating a new server connection {:?}", self.address);
+        let server_id = rand::random::<i32>();

-        let stats = Arc::new(ServerStats::new(
-            self.address.clone(),
-            self.stats.clone(),
-            tokio::time::Instant::now(),
-        ));
-
-        stats.register(stats.clone());
+        self.stats.server_register(
+            server_id,
+            self.address.id,
+            self.address.name(),
+            self.address.pool_name.clone(),
+            self.address.username.clone(),
+        );
+        self.stats.server_login(server_id);

        // Connect to the PostgreSQL server.
        match Server::startup(
+            server_id,
            &self.address,
            &self.user,
            &self.database,
            self.client_server_map.clone(),
-            stats.clone(),
-            self.auth_hash.clone(),
+            self.stats.clone(),
        )
        .await
        {
            Ok(conn) => {
-                stats.idle();
+                self.stats.server_idle(server_id);
                Ok(conn)
            }
            Err(err) => {
-                stats.disconnect();
+                self.stats.server_disconnecting(server_id);
                Err(err)
            }
        }
@@ -941,3 +881,11 @@ pub fn get_pool(db: &str, user: &str) -> Option<ConnectionPool> {
 pub fn get_all_pools() -> HashMap<PoolIdentifier, ConnectionPool> {
    (*(*POOLS.load())).clone()
 }
+
+/// How many total servers we have in the config.
+pub fn get_number_of_addresses() -> usize {
+    get_all_pools()
+        .iter()
+        .map(|(_, pool)| pool.databases())
+        .sum()
+}
--- a/src/prometheus.rs
+++ b/src/prometheus.rs
@@ -5,12 +5,10 @@ use phf::phf_map;
 use std::collections::HashMap;
 use std::fmt;
 use std::net::SocketAddr;
-use std::sync::atomic::Ordering;
-use std::sync::Arc;

 use crate::config::Address;
 use crate::pool::get_all_pools;
-use crate::stats::{get_pool_stats, get_server_stats, ServerStats};
+use crate::stats::{get_address_stats, get_pool_stats, get_server_stats, ServerInformation};

 struct MetricHelpType {
    help: &'static str,
@@ -222,7 +220,7 @@ impl<Value: fmt::Display> PrometheusMetric<Value> {
        Self::from_name(&format!("servers_{}", name), value, labels)
    }

-    fn from_address(address: &Address, name: &str, value: u64) -> Option<PrometheusMetric<u64>> {
+    fn from_address(address: &Address, name: &str, value: i64) -> Option<PrometheusMetric<i64>> {
        let mut labels = HashMap::new();
        labels.insert("host", address.host.clone());
        labels.insert("shard", address.shard.to_string());
@@ -233,7 +231,7 @@ impl<Value: fmt::Display> PrometheusMetric<Value> {
        Self::from_name(&format!("stats_{}", name), value, labels)
    }

-    fn from_pool(pool: &(String, String), name: &str, value: u64) -> Option<PrometheusMetric<u64>> {
+    fn from_pool(pool: &(String, String), name: &str, value: i64) -> Option<PrometheusMetric<i64>> {
        let mut labels = HashMap::new();
        labels.insert("pool", pool.0.clone());
        labels.insert("user", pool.1.clone());
@@ -263,18 +261,20 @@ async fn prometheus_stats(request: Request<Body>) -> Result<Response<Body>, hype

 // Adds metrics shown in a SHOW STATS admin command.
 fn push_address_stats(lines: &mut Vec<String>) {
+    let address_stats: HashMap<usize, HashMap<String, i64>> = get_address_stats();
    for (_, pool) in get_all_pools() {
        for shard in 0..pool.shards() {
            for server in 0..pool.servers(shard) {
                let address = pool.address(shard, server);
-                let stats = &*address.stats;
-                for (key, value) in stats.clone() {
-                    if let Some(prometheus_metric) =
-                        PrometheusMetric::<u64>::from_address(address, &key, value)
-                    {
-                        lines.push(prometheus_metric.to_string());
-                    } else {
-                        warn!("Metric {} not implemented for {}", key, address.name());
+                if let Some(address_stats) = address_stats.get(&address.id) {
+                    for (key, value) in address_stats.iter() {
+                        if let Some(prometheus_metric) =
+                            PrometheusMetric::<i64>::from_address(address, key, *value)
+                        {
+                            lines.push(prometheus_metric.to_string());
+                        } else {
+                            warn!("Metric {} not implemented for {}", key, address.name());
+                        }
                    }
                }
            }
@@ -286,9 +286,8 @@ fn push_address_stats(lines: &mut Vec<String>) {
 fn push_pool_stats(lines: &mut Vec<String>) {
    let pool_stats = get_pool_stats();
    for (pool, stats) in pool_stats.iter() {
-        let stats = &**stats;
-        for (name, value) in stats.clone() {
-            if let Some(prometheus_metric) = PrometheusMetric::<u64>::from_pool(pool, &name, value)
+        for (name, value) in stats.iter() {
+            if let Some(prometheus_metric) = PrometheusMetric::<i64>::from_pool(pool, name, *value)
            {
                lines.push(prometheus_metric.to_string());
            } else {
@@ -331,9 +330,9 @@ fn push_database_stats(lines: &mut Vec<String>) {
 // Adds relevant metrics shown in a SHOW SERVERS admin command.
 fn push_server_stats(lines: &mut Vec<String>) {
    let server_stats = get_server_stats();
-    let mut server_stats_by_addresses = HashMap::<String, Arc<ServerStats>>::new();
-    for (_, stats) in server_stats {
-        server_stats_by_addresses.insert(stats.address_name(), stats);
+    let mut server_stats_by_addresses = HashMap::<String, ServerInformation>::new();
+    for (_, info) in server_stats {
+        server_stats_by_addresses.insert(info.address_name.clone(), info);
    }

    for (_, pool) in get_all_pools() {
@@ -342,23 +341,11 @@ fn push_server_stats(lines: &mut Vec<String>) {
                let address = pool.address(shard, server);
                if let Some(server_info) = server_stats_by_addresses.get(&address.name()) {
                    let metrics = [
-                        (
-                            "bytes_received",
-                            server_info.bytes_received.load(Ordering::Relaxed),
-                        ),
-                        ("bytes_sent", server_info.bytes_sent.load(Ordering::Relaxed)),
-                        (
-                            "transaction_count",
-                            server_info.transaction_count.load(Ordering::Relaxed),
-                        ),
-                        (
-                            "query_count",
-                            server_info.query_count.load(Ordering::Relaxed),
-                        ),
-                        (
-                            "error_count",
-                            server_info.error_count.load(Ordering::Relaxed),
-                        ),
+                        ("bytes_received", server_info.bytes_received),
+                        ("bytes_sent", server_info.bytes_sent),
+                        ("transaction_count", server_info.transaction_count),
+                        ("query_count", server_info.query_count),
+                        ("error_count", server_info.error_count),
                    ];
                    for (key, value) in metrics {
                        if let Some(prometheus_metric) =
--- a/src/query_router.rs
+++ b/src/query_router.rs
@@ -1,4 +1,4 @@
-/// Route queries automatically based on explicitly requested
+/// Route queries automatically based on explicitely requested
 /// or implied query characteristics.
 use bytes::{Buf, BytesMut};
 use log::{debug, error};
@@ -1110,9 +1110,6 @@ mod test {
            sharding_key_regex: None,
            shard_id_regex: None,
            regex_search_limit: 1000,
-            auth_query: None,
-            auth_query_password: None,
-            auth_query_user: None,
        };
        let mut qr = QueryRouter::new();
        assert_eq!(qr.active_role, None);
@@ -1174,9 +1171,6 @@ mod test {
            sharding_key_regex: Some(Regex::new(r"/\* sharding_key: (\d+) \*/").unwrap()),
            shard_id_regex: Some(Regex::new(r"/\* shard_id: (\d+) \*/").unwrap()),
            regex_search_limit: 1000,
-            auth_query: None,
-            auth_query_password: None,
-            auth_query_user: None,
        };
        let mut qr = QueryRouter::new();
        qr.update_pool_settings(pool_settings.clone());
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,13 +1,8 @@
 /// Implementation of the PostgreSQL server (database) protocol.
 /// Here we are pretending to the a Postgres client.
 use bytes::{Buf, BufMut, BytesMut};
-use fallible_iterator::FallibleIterator;
 use log::{debug, error, info, trace, warn};
-use parking_lot::{Mutex, RwLock};
-use postgres_protocol::message;
-use std::collections::HashMap;
 use std::io::Read;
-use std::sync::Arc;
 use std::time::SystemTime;
 use tokio::io::{AsyncReadExt, BufReader};
 use tokio::net::{
@@ -17,15 +12,17 @@ use tokio::net::{

 use crate::config::{Address, User};
 use crate::constants::*;
-use crate::errors::{Error, ServerIdentifier};
+use crate::errors::Error;
 use crate::messages::*;
 use crate::mirrors::MirroringManager;
 use crate::pool::ClientServerMap;
 use crate::scram::ScramSha256;
-use crate::stats::ServerStats;
+use crate::stats::Reporter;

 /// Server state.
 pub struct Server {
+    server_id: i32,
+
    /// Server host, e.g. localhost,
    /// port, e.g. 5432, and role, e.g. primary or replica.
    address: Address,
@@ -38,7 +35,6 @@ pub struct Server {

    /// Our server response buffer. We buffer data before we give it to the client.
    buffer: BytesMut,
-    is_async: bool,

    /// Server information the server sent us over on startup.
    server_info: BytesMut,
@@ -66,7 +62,7 @@ pub struct Server {
    connected_at: chrono::naive::NaiveDateTime,

    /// Reports various metrics, e.g. data sent & received.
-    stats: Arc<ServerStats>,
+    stats: Reporter,

    /// Application name using the server at the moment.
    application_name: String,
@@ -81,12 +77,12 @@ impl Server {
    /// Pretend to be the Postgres client and connect to the server given host, port and credentials.
    /// Perform the authentication and return the server in a ready for query state.
    pub async fn startup(
+        server_id: i32,
        address: &Address,
        user: &User,
        database: &str,
        client_server_map: ClientServerMap,
-        stats: Arc<ServerStats>,
-        auth_hash: Arc<RwLock<Option<String>>>,
+        stats: Reporter,
    ) -> Result<Server, Error> {
        let mut stream =
            match TcpStream::connect(&format!("{}:{}", &address.host, address.port)).await {
@@ -104,52 +100,25 @@ impl Server {
        trace!("Sending StartupMessage");

        // StartupMessage
-        let username = match user.server_username {
-            Some(ref server_username) => server_username,
-            None => &user.username,
-        };
-
-        let password = match user.server_password {
-            Some(ref server_password) => Some(server_password),
-            None => match user.password {
-                Some(ref password) => Some(password),
-                None => None,
-            },
-        };
-
-        startup(&mut stream, username, database).await?;
+        startup(&mut stream, &user.username, database).await?;

        let mut server_info = BytesMut::new();
        let mut process_id: i32 = 0;
        let mut secret_key: i32 = 0;
-        let server_identifier = ServerIdentifier::new(username, &database);

        // We'll be handling multiple packets, but they will all be structured the same.
        // We'll loop here until this exchange is complete.
-        let mut scram: Option<ScramSha256> = match password {
-            Some(password) => Some(ScramSha256::new(password)),
-            None => None,
-        };
+        let mut scram = ScramSha256::new(&user.password);

        loop {
            let code = match stream.read_u8().await {
                Ok(code) => code as char,
-                Err(_) => {
-                    return Err(Error::ServerStartupError(
-                        "message code".into(),
-                        server_identifier,
-                    ))
-                }
+                Err(_) => return Err(Error::SocketError(format!("Error reading message code on server startup {{ username: {:?}, database: {:?} }}", user.username, database))),
            };

            let len = match stream.read_i32().await {
                Ok(len) => len,
-                Err(_) => {
-                    return Err(Error::ServerStartupError(
-                        "message len".into(),
-                        server_identifier,
-                    ))
-                }
+                Err(_) => return Err(Error::SocketError(format!("Error reading message len on server startup {{ username: {:?}, database: {:?} }}", user.username, database))),
            };

            trace!("Message: {}", code);
@@ -160,12 +129,7 @@ impl Server {
                    // Determine which kind of authentication is required, if any.
                    let auth_code = match stream.read_i32().await {
                        Ok(auth_code) => auth_code,
-                        Err(_) => {
-                            return Err(Error::ServerStartupError(
-                                "auth code".into(),
-                                server_identifier,
-                            ))
-                        }
+                        Err(_) => return Err(Error::SocketError(format!("Error reading auth code on server startup {{ username: {:?}, database: {:?} }}", user.username, database))),
                    };

                    trace!("Auth: {}", auth_code);
@@ -178,70 +142,23 @@ impl Server {

                            match stream.read_exact(&mut salt).await {
                                Ok(_) => (),
-                                Err(_) => {
-                                    return Err(Error::ServerStartupError(
-                                        "salt".into(),
-                                        server_identifier,
-                                    ))
-                                }
+                                Err(_) => return Err(Error::SocketError(format!("Error reading salt on server startup {{ username: {:?}, database: {:?} }}", user.username, database))),
                            };

-                            match password {
-                                // Using plaintext password
-                                Some(password) => {
-                                    md5_password(&mut stream, username, password, &salt[..]).await?
-                                }
-
-                                // Using auth passthrough, in this case we should already have a
-                                // hash obtained when the pool was validated. If we reach this point
-                                // and don't have a hash, we return an error.
-                                None => {
-                                    let option_hash = (*auth_hash.read()).clone();
-                                    match option_hash {
-                                        Some(hash) =>
-                                            md5_password_with_hash(
-                                                &mut stream,
-                                                &hash,
-                                                &salt[..],
-                                            )
-                                            .await?,
-                                        None => return Err(
-                                            Error::ServerAuthError(
-                                                "Auth passthrough (auth_query) failed and no user password is set in cleartext".into(),
-                                                server_identifier
-                                            )
-                                        ),
-                                    }
-                                }
-                            }
+                            md5_password(&mut stream, &user.username, &user.password, &salt[..])
+                                .await?;
                        }

                        AUTHENTICATION_SUCCESSFUL => (),

                        SASL => {
-                            if scram.is_none() {
-                                return Err(Error::ServerAuthError(
-                                    "SASL auth required and no password specified. \
-                                    Auth passthrough (auth_query) method is currently \
-                                    unsupported for SASL auth"
-                                        .into(),
-                                    server_identifier,
-                                ));
-                            }
-
                            debug!("Starting SASL authentication");
-
                            let sasl_len = (len - 8) as usize;
                            let mut sasl_auth = vec![0u8; sasl_len];

                            match stream.read_exact(&mut sasl_auth).await {
                                Ok(_) => (),
-                                Err(_) => {
-                                    return Err(Error::ServerStartupError(
-                                        "sasl message".into(),
-                                        server_identifier,
-                                    ))
-                                }
+                                Err(_) => return Err(Error::SocketError(format!("Error reading sasl message on server startup {{ username: {:?}, database: {:?} }}", user.username, database))),
                            };

                            let sasl_type = String::from_utf8_lossy(&sasl_auth[..sasl_len - 2]);
@@ -250,7 +167,7 @@ impl Server {
                                debug!("Using {}", SCRAM_SHA_256);

                                // Generate client message.
-                                let sasl_response = scram.as_mut().unwrap().message();
+                                let sasl_response = scram.message();

                                // SASLInitialResponse (F)
                                let mut res = BytesMut::new();
@@ -283,16 +200,11 @@ impl Server {

                            match stream.read_exact(&mut sasl_data).await {
                                Ok(_) => (),
-                                Err(_) => {
-                                    return Err(Error::ServerStartupError(
-                                        "sasl cont message".into(),
-                                        server_identifier,
-                                    ))
-                                }
+                                Err(_) => return Err(Error::SocketError(format!("Error reading sasl cont message on server startup {{ username: {:?}, database: {:?} }}", user.username, database))),
                            };

                            let msg = BytesMut::from(&sasl_data[..]);
-                            let sasl_response = scram.as_mut().unwrap().update(&msg)?;
+                            let sasl_response = scram.update(&msg)?;

                            // SASLResponse
                            let mut res = BytesMut::new();
@@ -309,19 +221,10 @@ impl Server {
                            let mut sasl_final = vec![0u8; len as usize - 8];
                            match stream.read_exact(&mut sasl_final).await {
                                Ok(_) => (),
-                                Err(_) => {
-                                    return Err(Error::ServerStartupError(
-                                        "sasl final message".into(),
-                                        server_identifier,
-                                    ))
-                                }
+                                Err(_) => return Err(Error::SocketError(format!("Error reading sasl final message on server startup {{ username: {:?}, database: {:?} }}", user.username, database))),
                            };

-                            match scram
-                                .as_mut()
-                                .unwrap()
-                                .finish(&BytesMut::from(&sasl_final[..]))
-                            {
+                            match scram.finish(&BytesMut::from(&sasl_final[..])) {
                                Ok(_) => {
                                    debug!("SASL authentication successful");
                                }
@@ -344,12 +247,7 @@ impl Server {
                'E' => {
                    let error_code = match stream.read_u8().await {
                        Ok(error_code) => error_code,
-                        Err(_) => {
-                            return Err(Error::ServerStartupError(
-                                "error code message".into(),
-                                server_identifier,
-                            ))
-                        }
+                        Err(_) => return Err(Error::SocketError(format!("Error reading error code message on server startup {{ username: {:?}, database: {:?} }}", user.username, database))),
                    };

                    trace!("Error: {}", error_code);
@@ -365,12 +263,7 @@ impl Server {

                            match stream.read_exact(&mut error).await {
                                Ok(_) => (),
-                                Err(_) => {
-                                    return Err(Error::ServerStartupError(
-                                        "error message".into(),
-                                        server_identifier,
-                                    ))
-                                }
+                                Err(_) => return Err(Error::SocketError(format!("Error reading error message on server startup {{ username: {:?}, database: {:?} }}", user.username, database))),
                            };

                            // TODO: the error message contains multiple fields; we can decode them and
@@ -389,12 +282,7 @@ impl Server {

                    match stream.read_exact(&mut param).await {
                        Ok(_) => (),
-                        Err(_) => {
-                            return Err(Error::ServerStartupError(
-                                "parameter status message".into(),
-                                server_identifier,
-                            ))
-                        }
+                        Err(_) => return Err(Error::SocketError(format!("Error reading parameter status message on server startup {{ username: {:?}, database: {:?} }}", user.username, database))),
                    };

                    // Save the parameter so we can pass it to the client later.
@@ -411,22 +299,12 @@ impl Server {
                    // See: <https://www.postgresql.org/docs/12/protocol-message-formats.html>.
                    process_id = match stream.read_i32().await {
                        Ok(id) => id,
-                        Err(_) => {
-                            return Err(Error::ServerStartupError(
-                                "process id message".into(),
-                                server_identifier,
-                            ))
-                        }
+                        Err(_) => return Err(Error::SocketError(format!("Error reading process id message on server startup {{ username: {:?}, database: {:?} }}", user.username, database))),
                    };

                    secret_key = match stream.read_i32().await {
                        Ok(id) => id,
-                        Err(_) => {
-                            return Err(Error::ServerStartupError(
-                                "secret key message".into(),
-                                server_identifier,
-                            ))
-                        }
+                        Err(_) => return Err(Error::SocketError(format!("Error reading secret key message on server startup {{ username: {:?}, database: {:?} }}", user.username, database))),
                    };
                }

@@ -436,12 +314,7 @@ impl Server {

                    match stream.read_exact(&mut idle).await {
                        Ok(_) => (),
-                        Err(_) => {
-                            return Err(Error::ServerStartupError(
-                                "transaction status message".into(),
-                                server_identifier,
-                            ))
-                        }
+                        Err(_) => return Err(Error::SocketError(format!("Error reading transaction status message on server startup {{ username: {:?}, database: {:?} }}", user.username, database))),
                    };

                    let (read, write) = stream.into_split();
@@ -451,8 +324,8 @@ impl Server {
                        read: BufReader::new(read),
                        write,
                        buffer: BytesMut::with_capacity(8196),
-                        is_async: false,
                        server_info,
+                        server_id,
                        process_id,
                        secret_key,
                        in_transaction: false,
@@ -504,7 +377,7 @@ impl Server {
            Ok(stream) => stream,
            Err(err) => {
                error!("Could not connect to server: {}", err);
-                return Err(Error::SocketError("Error reading cancel message".into()));
+                return Err(Error::SocketError(format!("Error reading cancel message")));
            }
        };
        configure_socket(&stream);
@@ -523,7 +396,7 @@ impl Server {
    /// Send messages to the server from the client.
    pub async fn send(&mut self, messages: &BytesMut) -> Result<(), Error> {
        self.mirror_send(messages);
-        self.stats().data_sent(messages.len());
+        self.stats.data_sent(messages.len(), self.server_id);

        match write_all_half(&mut self.write, messages).await {
            Ok(_) => {
@@ -539,16 +412,6 @@ impl Server {
        }
    }

-    /// Switch to async mode, flushing messages as soon
-    /// as we receive them without buffering or waiting for "ReadyForQuery".
-    pub fn switch_async(&mut self, on: bool) {
-        if on {
-            self.is_async = true;
-        } else {
-            self.is_async = false;
-        }
-    }
-
    /// Receive data from the server in response to a client request.
    /// This method must be called multiple times while `self.is_data_available()` is true
    /// in order to receive all data the server has to offer.
@@ -644,10 +507,7 @@ impl Server {
                // DataRow
                'D' => {
                    // More data is available after this message, this is not the end of the reply.
-                    // If we're async, flush to client now.
-                    if !self.is_async {
-                        self.data_available = true;
-                    }
+                    self.data_available = true;

                    // Don't flush yet, the more we buffer, the faster this goes...up to a limit.
                    if self.buffer.len() >= 8196 {
@@ -660,10 +520,7 @@ impl Server {

                // CopyOutResponse: copy is starting from the server to the client.
                'H' => {
-                    // If we're in async mode, flush now.
-                    if !self.is_async {
-                        self.data_available = true;
-                    }
+                    self.data_available = true;
                    break;
                }

@@ -683,16 +540,12 @@ impl Server {
                // Keep buffering until ReadyForQuery shows up.
                _ => (),
            };
-
-            if self.is_async {
-                break;
-            }
        }

        let bytes = self.buffer.clone();

        // Keep track of how much data we got from the server for stats.
-        self.stats().data_received(bytes.len());
+        self.stats.data_received(bytes.len(), self.server_id);

        // Clear the buffer for next query.
        self.buffer.clear();
@@ -812,17 +665,18 @@ impl Server {
        }
    }

-    /// get Server stats
-    pub fn stats(&self) -> Arc<ServerStats> {
-        self.stats.clone()
-    }
-
    /// Get the servers address.
    #[allow(dead_code)]
    pub fn address(&self) -> Address {
        self.address.clone()
    }

+    /// Get the server connection identifier
+    /// Used to uniquely identify connection in statistics
+    pub fn server_id(&self) -> i32 {
+        self.server_id
+    }
+
    // Get server's latest response timestamp
    pub fn last_activity(&self) -> SystemTime {
        self.last_activity
@@ -846,105 +700,6 @@ impl Server {
            None => (),
        }
    }
-
-    // This is so we can execute out of band queries to the server.
-    // The connection will be opened, the query executed and closed.
-    pub async fn exec_simple_query(
-        address: &Address,
-        user: &User,
-        query: &str,
-    ) -> Result<Vec<String>, Error> {
-        let client_server_map: ClientServerMap = Arc::new(Mutex::new(HashMap::new()));
-
-        debug!("Connecting to server to obtain auth hashes.");
-        let mut server = Server::startup(
-            address,
-            user,
-            &address.database,
-            client_server_map,
-            Arc::new(ServerStats::default()),
-            Arc::new(RwLock::new(None)),
-        )
-        .await?;
-        debug!("Connected!, sending query.");
-        server.send(&simple_query(query)).await?;
-        let mut message = server.recv().await?;
-
-        Ok(parse_query_message(&mut message).await?)
-    }
-}
-
-async fn parse_query_message(message: &mut BytesMut) -> Result<Vec<String>, Error> {
-    let mut pair = Vec::<String>::new();
-    match message::backend::Message::parse(message) {
-        Ok(Some(message::backend::Message::RowDescription(_description))) => {}
-        Ok(Some(message::backend::Message::ErrorResponse(err))) => {
-            return Err(Error::ProtocolSyncError(format!(
-                "Protocol error parsing response. Err: {:?}",
-                err.fields()
-                    .iterator()
-                    .fold(String::default(), |acc, element| acc
-                        + element.unwrap().value())
-            )))
-        }
-        Ok(_) => {
-            return Err(Error::ProtocolSyncError(
-                "Protocol error, expected Row Description.".to_string(),
-            ))
-        }
-        Err(err) => {
-            return Err(Error::ProtocolSyncError(format!(
-                "Protocol error parsing response. Err: {:?}",
-                err
-            )))
-        }
-    }
-
-    while !message.is_empty() {
-        match message::backend::Message::parse(message) {
-            Ok(postgres_message) => {
-                match postgres_message {
-                    Some(message::backend::Message::DataRow(data)) => {
-                        let buf = data.buffer();
-                        trace!("Data: {:?}", buf);
-
-                        for item in data.ranges().iterator() {
-                            match item.as_ref() {
-                                Ok(range) => match range {
-                                    Some(range) => {
-                                        pair.push(String::from_utf8_lossy(&buf[range.clone()]).to_string());
-                                    }
-                                    None => return Err(Error::ProtocolSyncError(String::from(
-                                        "Data expected while receiving query auth data, found nothing.",
-                                    ))),
-                                },
-                                Err(err) => {
-                                    return Err(Error::ProtocolSyncError(format!(
-                                        "Data error, err: {:?}",
-                                        err
-                                    )))
-                                }
-                            }
-                        }
-                    }
-                    Some(message::backend::Message::CommandComplete(_)) => {}
-                    Some(message::backend::Message::ReadyForQuery(_)) => {}
-                    _ => {
-                        return Err(Error::ProtocolSyncError(
-                            "Unexpected message while receiving auth query data.".to_string(),
-                        ))
-                    }
-                }
-            }
-            Err(err) => {
-                return Err(Error::ProtocolSyncError(format!(
-                    "Parse error, err: {:?}",
-                    err
-                )))
-            }
-        };
-    }
-    Ok(pair)
 }

 impl Drop for Server {
@@ -953,9 +708,7 @@ impl Drop for Server {
    /// for a write.
    fn drop(&mut self) {
        self.mirror_disconnect();
-
-        // Update statistics
-        self.stats.disconnect();
+        self.stats.server_disconnecting(self.server_id);

        let mut bytes = BytesMut::with_capacity(4);
        bytes.put_u8(b'X');
--- a/src/stats.rs
+++ b/src/stats.rs
--- a/src/stats/address.rs
+++ b/src/stats/address.rs
@@ -1,149 +0,0 @@
-use log::warn;
-use std::sync::atomic::*;
-use std::sync::Arc;
-
-/// Internal address stats
-#[derive(Debug, Clone, Default)]
-pub struct AddressStats {
-    pub total_xact_count: Arc<AtomicU64>,
-    pub total_query_count: Arc<AtomicU64>,
-    pub total_received: Arc<AtomicU64>,
-    pub total_sent: Arc<AtomicU64>,
-    pub total_xact_time: Arc<AtomicU64>,
-    pub total_query_time: Arc<AtomicU64>,
-    pub total_wait_time: Arc<AtomicU64>,
-    pub total_errors: Arc<AtomicU64>,
-    pub avg_query_count: Arc<AtomicU64>,
-    pub avg_query_time: Arc<AtomicU64>,
-    pub avg_recv: Arc<AtomicU64>,
-    pub avg_sent: Arc<AtomicU64>,
-    pub avg_errors: Arc<AtomicU64>,
-    pub avg_xact_time: Arc<AtomicU64>,
-    pub avg_xact_count: Arc<AtomicU64>,
-    pub avg_wait_time: Arc<AtomicU64>,
-}
-
-impl IntoIterator for AddressStats {
-    type Item = (String, u64);
-    type IntoIter = std::vec::IntoIter<Self::Item>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        vec![
-            (
-                "total_xact_count".to_string(),
-                self.total_xact_count.load(Ordering::Relaxed),
-            ),
-            (
-                "total_query_count".to_string(),
-                self.total_query_count.load(Ordering::Relaxed),
-            ),
-            (
-                "total_received".to_string(),
-                self.total_received.load(Ordering::Relaxed),
-            ),
-            (
-                "total_sent".to_string(),
-                self.total_sent.load(Ordering::Relaxed),
-            ),
-            (
-                "total_xact_time".to_string(),
-                self.total_xact_time.load(Ordering::Relaxed),
-            ),
-            (
-                "total_query_time".to_string(),
-                self.total_query_time.load(Ordering::Relaxed),
-            ),
-            (
-                "total_wait_time".to_string(),
-                self.total_wait_time.load(Ordering::Relaxed),
-            ),
-            (
-                "total_errors".to_string(),
-                self.total_errors.load(Ordering::Relaxed),
-            ),
-            (
-                "avg_xact_count".to_string(),
-                self.avg_xact_count.load(Ordering::Relaxed),
-            ),
-            (
-                "avg_query_count".to_string(),
-                self.avg_query_count.load(Ordering::Relaxed),
-            ),
-            (
-                "avg_recv".to_string(),
-                self.avg_recv.load(Ordering::Relaxed),
-            ),
-            (
-                "avg_sent".to_string(),
-                self.avg_sent.load(Ordering::Relaxed),
-            ),
-            (
-                "avg_errors".to_string(),
-                self.avg_errors.load(Ordering::Relaxed),
-            ),
-            (
-                "avg_xact_time".to_string(),
-                self.avg_xact_time.load(Ordering::Relaxed),
-            ),
-            (
-                "avg_query_time".to_string(),
-                self.avg_query_time.load(Ordering::Relaxed),
-            ),
-            (
-                "avg_wait_time".to_string(),
-                self.avg_wait_time.load(Ordering::Relaxed),
-            ),
-        ]
-        .into_iter()
-    }
-}
-
-impl AddressStats {
-    pub fn error(&self) {
-        self.total_errors.fetch_add(1, Ordering::Relaxed);
-    }
-
-    pub fn update_averages(&self) {
-        let (totals, averages) = self.fields_iterators();
-        for data in totals.iter().zip(averages.iter()) {
-            let (total, average) = data;
-            if let Err(err) = average.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |avg| {
-                let total = total.load(Ordering::Relaxed);
-                let avg = (total - avg) / (crate::stats::STAT_PERIOD / 1_000); // Avg / second
-                Some(avg)
-            }) {
-                warn!("Could not update averages for addresses stats, {:?}", err);
-            }
-        }
-    }
-
-    pub fn populate_row(&self, row: &mut Vec<String>) {
-        for (_key, value) in self.clone() {
-            row.push(value.to_string());
-        }
-    }
-
-    fn fields_iterators(&self) -> (Vec<Arc<AtomicU64>>, Vec<Arc<AtomicU64>>) {
-        let mut totals: Vec<Arc<AtomicU64>> = Vec::new();
-        let mut averages: Vec<Arc<AtomicU64>> = Vec::new();
-
-        totals.push(self.total_xact_count.clone());
-        averages.push(self.avg_xact_count.clone());
-        totals.push(self.total_query_count.clone());
-        averages.push(self.avg_query_count.clone());
-        totals.push(self.total_received.clone());
-        averages.push(self.avg_recv.clone());
-        totals.push(self.total_sent.clone());
-        averages.push(self.avg_sent.clone());
-        totals.push(self.total_xact_time.clone());
-        averages.push(self.avg_xact_time.clone());
-        totals.push(self.total_query_time.clone());
-        averages.push(self.avg_query_time.clone());
-        totals.push(self.total_wait_time.clone());
-        averages.push(self.avg_wait_time.clone());
-        totals.push(self.total_errors.clone());
-        averages.push(self.avg_errors.clone());
-
-        (totals, averages)
-    }
-}
--- a/src/stats/client.rs
+++ b/src/stats/client.rs
@@ -1,182 +0,0 @@
-use super::PoolStats;
-use super::{get_reporter, Reporter};
-use atomic_enum::atomic_enum;
-use std::sync::atomic::*;
-use std::sync::Arc;
-use tokio::time::Instant;
-/// The various states that a client can be in
-#[atomic_enum]
-#[derive(PartialEq)]
-pub enum ClientState {
-    Idle = 0,
-    Waiting,
-    Active,
-}
-impl std::fmt::Display for ClientState {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match *self {
-            ClientState::Idle => write!(f, "idle"),
-            ClientState::Waiting => write!(f, "waiting"),
-            ClientState::Active => write!(f, "active"),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-/// Information we keep track of which can be queried by SHOW CLIENTS
-pub struct ClientStats {
-    /// A random integer assigned to the client and used by stats to track the client
-    client_id: i32,
-
-    /// Data associated with the client, not writable, only set when we construct the ClientStat
-    application_name: String,
-    username: String,
-    pool_name: String,
-    connect_time: Instant,
-
-    pool_stats: Arc<PoolStats>,
-    reporter: Reporter,
-
-    /// Total time spent waiting for a connection from pool, measures in microseconds
-    pub total_wait_time: Arc<AtomicU64>,
-
-    /// Current state of the client
-    pub state: Arc<AtomicClientState>,
-
-    /// Number of transactions executed by this client
-    pub transaction_count: Arc<AtomicU64>,
-
-    /// Number of queries executed by this client
-    pub query_count: Arc<AtomicU64>,
-
-    /// Number of errors made by this client
-    pub error_count: Arc<AtomicU64>,
-}
-
-impl Default for ClientStats {
-    fn default() -> Self {
-        ClientStats {
-            client_id: 0,
-            connect_time: Instant::now(),
-            application_name: String::new(),
-            username: String::new(),
-            pool_name: String::new(),
-            pool_stats: Arc::new(PoolStats::default()),
-            total_wait_time: Arc::new(AtomicU64::new(0)),
-            state: Arc::new(AtomicClientState::new(ClientState::Idle)),
-            transaction_count: Arc::new(AtomicU64::new(0)),
-            query_count: Arc::new(AtomicU64::new(0)),
-            error_count: Arc::new(AtomicU64::new(0)),
-            reporter: get_reporter(),
-        }
-    }
-}
-
-impl ClientStats {
-    pub fn new(
-        client_id: i32,
-        application_name: &str,
-        username: &str,
-        pool_name: &str,
-        connect_time: Instant,
-        pool_stats: Arc<PoolStats>,
-    ) -> Self {
-        Self {
-            client_id,
-            pool_stats,
-            connect_time,
-            application_name: application_name.to_string(),
-            username: username.to_string(),
-            pool_name: pool_name.to_string(),
-            ..Default::default()
-        }
-    }
-
-    /// Reports a client is disconnecting from the pooler and
-    /// update metrics on the corresponding pool.
-    pub fn disconnect(&self) {
-        self.reporter.client_disconnecting(self.client_id);
-        self.pool_stats
-            .client_disconnect(self.state.load(Ordering::Relaxed))
-    }
-
-    /// Register a client with the stats system. The stats system uses client_id
-    /// to track and aggregate statistics from all source that relate to that client
-    pub fn register(&self, stats: Arc<ClientStats>) {
-        self.reporter.client_register(self.client_id, stats);
-        self.state.store(ClientState::Idle, Ordering::Relaxed);
-        self.pool_stats.cl_idle.fetch_add(1, Ordering::Relaxed);
-    }
-
-    /// Reports a client is done querying the server and is no longer assigned a server connection
-    pub fn idle(&self) {
-        self.pool_stats
-            .client_idle(self.state.load(Ordering::Relaxed));
-        self.state.store(ClientState::Idle, Ordering::Relaxed);
-    }
-
-    /// Reports a client is waiting for a connection
-    pub fn waiting(&self) {
-        self.pool_stats
-            .client_waiting(self.state.load(Ordering::Relaxed));
-        self.state.store(ClientState::Waiting, Ordering::Relaxed);
-    }
-
-    /// Reports a client is done waiting for a connection and is about to query the server.
-    pub fn active(&self) {
-        self.pool_stats
-            .client_active(self.state.load(Ordering::Relaxed));
-        self.state.store(ClientState::Active, Ordering::Relaxed);
-    }
-
-    /// Reports a client has failed to obtain a connection from a connection pool
-    pub fn checkout_error(&self) {
-        self.state.store(ClientState::Idle, Ordering::Relaxed);
-    }
-
-    /// Reports a client has had the server assigned to it be banned
-    pub fn ban_error(&self) {
-        self.state.store(ClientState::Idle, Ordering::Relaxed);
-        self.error_count.fetch_add(1, Ordering::Relaxed);
-    }
-
-    /// Reporters the time spent by a client waiting to get a healthy connection from the pool
-    pub fn checkout_time(&self, microseconds: u64) {
-        self.total_wait_time
-            .fetch_add(microseconds, Ordering::Relaxed);
-    }
-
-    /// Report a query executed by a client against a server
-    pub fn query(&self) {
-        self.query_count.fetch_add(1, Ordering::Relaxed);
-    }
-
-    /// Report a transaction executed by a client a server
-    /// we report each individual queries outside a transaction as a transaction
-    /// We only count the initial BEGIN as a transaction, all queries within do not
-    /// count as transactions
-    pub fn transaction(&self) {
-        self.transaction_count.fetch_add(1, Ordering::Relaxed);
-    }
-
-    // Helper methods for show clients
-    pub fn connect_time(&self) -> Instant {
-        self.connect_time
-    }
-
-    pub fn client_id(&self) -> i32 {
-        self.client_id
-    }
-
-    pub fn application_name(&self) -> String {
-        self.application_name.clone()
-    }
-
-    pub fn username(&self) -> String {
-        self.username.clone()
-    }
-
-    pub fn pool_name(&self) -> String {
-        self.pool_name.clone()
-    }
-}
--- a/src/stats/pool.rs
+++ b/src/stats/pool.rs
@@ -1,274 +0,0 @@
-use crate::config::Pool;
-use crate::config::PoolMode;
-use crate::pool::PoolIdentifier;
-use std::sync::atomic::*;
-use std::sync::Arc;
-
-use super::get_reporter;
-use super::Reporter;
-use super::{ClientState, ServerState};
-
-#[derive(Debug, Clone, Default)]
-/// A struct that holds information about a Pool .
-pub struct PoolStats {
-    // Pool identifier, cannot be changed after creating the instance
-    identifier: PoolIdentifier,
-
-    // Pool Config, cannot be changed after creating the instance
-    config: Pool,
-
-    // A reference to the global reporter.
-    reporter: Reporter,
-
-    /// Counters (atomics)
-    pub cl_idle: Arc<AtomicU64>,
-    pub cl_active: Arc<AtomicU64>,
-    pub cl_waiting: Arc<AtomicU64>,
-    pub cl_cancel_req: Arc<AtomicU64>,
-    pub sv_active: Arc<AtomicU64>,
-    pub sv_idle: Arc<AtomicU64>,
-    pub sv_used: Arc<AtomicU64>,
-    pub sv_tested: Arc<AtomicU64>,
-    pub sv_login: Arc<AtomicU64>,
-    pub maxwait: Arc<AtomicU64>,
-}
-
-impl IntoIterator for PoolStats {
-    type Item = (String, u64);
-    type IntoIter = std::vec::IntoIter<Self::Item>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        vec![
-            ("cl_idle".to_string(), self.cl_idle.load(Ordering::Relaxed)),
-            (
-                "cl_active".to_string(),
-                self.cl_active.load(Ordering::Relaxed),
-            ),
-            (
-                "cl_waiting".to_string(),
-                self.cl_waiting.load(Ordering::Relaxed),
-            ),
-            (
-                "cl_cancel_req".to_string(),
-                self.cl_cancel_req.load(Ordering::Relaxed),
-            ),
-            (
-                "sv_active".to_string(),
-                self.sv_active.load(Ordering::Relaxed),
-            ),
-            ("sv_idle".to_string(), self.sv_idle.load(Ordering::Relaxed)),
-            ("sv_used".to_string(), self.sv_used.load(Ordering::Relaxed)),
-            (
-                "sv_tested".to_string(),
-                self.sv_tested.load(Ordering::Relaxed),
-            ),
-            (
-                "sv_login".to_string(),
-                self.sv_login.load(Ordering::Relaxed),
-            ),
-            (
-                "maxwait".to_string(),
-                self.maxwait.load(Ordering::Relaxed) / 1_000_000,
-            ),
-            (
-                "maxwait_us".to_string(),
-                self.maxwait.load(Ordering::Relaxed) % 1_000_000,
-            ),
-        ]
-        .into_iter()
-    }
-}
-
-impl PoolStats {
-    pub fn new(identifier: PoolIdentifier, config: Pool) -> Self {
-        Self {
-            identifier,
-            config,
-            reporter: get_reporter(),
-            ..Default::default()
-        }
-    }
-
-    // Getters
-    pub fn register(&self, stats: Arc<PoolStats>) {
-        self.reporter.pool_register(self.identifier.clone(), stats);
-    }
-
-    pub fn database(&self) -> String {
-        self.identifier.db.clone()
-    }
-
-    pub fn user(&self) -> String {
-        self.identifier.user.clone()
-    }
-
-    pub fn pool_mode(&self) -> PoolMode {
-        self.config.pool_mode
-    }
-
-    /// Populates an array of strings with counters (used by admin in show pools)
-    pub fn populate_row(&self, row: &mut Vec<String>) {
-        for (_key, value) in self.clone() {
-            row.push(value.to_string());
-        }
-    }
-
-    /// Deletes the maxwait counter, this is done everytime we obtain metrics
-    pub fn clear_maxwait(&self) {
-        self.maxwait.store(0, Ordering::Relaxed);
-    }
-
-    /// Notified when a server of the pool enters login state.
-    ///
-    /// Arguments:
-    ///
-    /// `from`: The state of the server that notifies.
-    pub fn server_login(&self, from: ServerState) {
-        self.sv_login.fetch_add(1, Ordering::Relaxed);
-        if from != ServerState::Login {
-            self.decrease_from_server_state(from);
-        }
-    }
-
-    /// Notified when a server of the pool become 'active'
-    ///
-    /// Arguments:
-    ///
-    /// `from`: The state of the server that notifies.
-    pub fn server_active(&self, from: ServerState) {
-        self.sv_active.fetch_add(1, Ordering::Relaxed);
-        if from != ServerState::Active {
-            self.decrease_from_server_state(from);
-        }
-    }
-
-    /// Notified when a server of the pool become 'tested'
-    ///
-    /// Arguments:
-    ///
-    /// `from`: The state of the server that notifies.
-    pub fn server_tested(&self, from: ServerState) {
-        self.sv_tested.fetch_add(1, Ordering::Relaxed);
-        if from != ServerState::Tested {
-            self.decrease_from_server_state(from);
-        }
-    }
-
-    /// Notified when a server of the pool become 'idle'
-    ///
-    /// Arguments:
-    ///
-    /// `from`: The state of the server that notifies.
-    pub fn server_idle(&self, from: ServerState) {
-        self.sv_idle.fetch_add(1, Ordering::Relaxed);
-        if from != ServerState::Idle {
-            self.decrease_from_server_state(from);
-        }
-    }
-
-    /// Notified when a client of the pool become 'waiting'
-    ///
-    /// Arguments:
-    ///
-    /// `from`: The state of the client that notifies.
-    pub fn client_waiting(&self, from: ClientState) {
-        if from != ClientState::Waiting {
-            self.cl_waiting.fetch_add(1, Ordering::Relaxed);
-            self.decrease_from_client_state(from);
-        }
-    }
-
-    /// Notified when a client of the pool become 'active'
-    ///
-    /// Arguments:
-    ///
-    /// `from`: The state of the client that notifies.
-    pub fn client_active(&self, from: ClientState) {
-        if from != ClientState::Active {
-            self.cl_active.fetch_add(1, Ordering::Relaxed);
-            self.decrease_from_client_state(from);
-        }
-    }
-
-    /// Notified when a client of the pool become 'idle'
-    ///
-    /// Arguments:
-    ///
-    /// `from`: The state of the client that notifies.
-    pub fn client_idle(&self, from: ClientState) {
-        if from != ClientState::Idle {
-            self.cl_idle.fetch_add(1, Ordering::Relaxed);
-            self.decrease_from_client_state(from);
-        }
-    }
-
-    /// Notified when a client disconnects.
-    ///
-    /// Arguments:
-    ///
-    /// `from`: The state of the client that notifies.
-    pub fn client_disconnect(&self, from: ClientState) {
-        let counter = match from {
-            ClientState::Idle => &self.cl_idle,
-            ClientState::Waiting => &self.cl_waiting,
-            ClientState::Active => &self.cl_active,
-        };
-
-        Self::decrease_counter(counter.clone());
-    }
-
-    /// Notified when a server disconnects.
-    ///
-    /// Arguments:
-    ///
-    /// `from`: The state of the client that notifies.
-    pub fn server_disconnect(&self, from: ServerState) {
-        let counter = match from {
-            ServerState::Active => &self.sv_active,
-            ServerState::Idle => &self.sv_idle,
-            ServerState::Login => &self.sv_login,
-            ServerState::Tested => &self.sv_tested,
-        };
-        Self::decrease_counter(counter.clone());
-    }
-
-    // helpers for counter decrease
-    fn decrease_from_server_state(&self, from: ServerState) {
-        let counter = match from {
-            ServerState::Tested => &self.sv_tested,
-            ServerState::Active => &self.sv_active,
-            ServerState::Idle => &self.sv_idle,
-            ServerState::Login => &self.sv_login,
-        };
-        Self::decrease_counter(counter.clone());
-    }
-
-    fn decrease_from_client_state(&self, from: ClientState) {
-        let counter = match from {
-            ClientState::Active => &self.cl_active,
-            ClientState::Idle => &self.cl_idle,
-            ClientState::Waiting => &self.cl_waiting,
-        };
-        Self::decrease_counter(counter.clone());
-    }
-
-    fn decrease_counter(value: Arc<AtomicU64>) {
-        if value.load(Ordering::Relaxed) > 0 {
-            value.fetch_sub(1, Ordering::Relaxed);
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_decrease() {
-        let stat: PoolStats = PoolStats::default();
-        stat.server_login(ServerState::Login);
-        stat.server_idle(ServerState::Login);
-        assert_eq!(stat.sv_login.load(Ordering::Relaxed), 0);
-        assert_eq!(stat.sv_idle.load(Ordering::Relaxed), 1);
-    }
-}
--- a/src/stats/server.rs
+++ b/src/stats/server.rs
@@ -1,225 +0,0 @@
-use super::AddressStats;
-use super::PoolStats;
-use super::{get_reporter, Reporter};
-use crate::config::Address;
-use atomic_enum::atomic_enum;
-use parking_lot::RwLock;
-use std::sync::atomic::*;
-use std::sync::Arc;
-use tokio::time::Instant;
-
-/// The various states that a server can be in
-#[atomic_enum]
-#[derive(PartialEq)]
-pub enum ServerState {
-    Login = 0,
-    Active,
-    Tested,
-    Idle,
-}
-impl std::fmt::Display for ServerState {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match *self {
-            ServerState::Login => write!(f, "login"),
-            ServerState::Active => write!(f, "active"),
-            ServerState::Tested => write!(f, "tested"),
-            ServerState::Idle => write!(f, "idle"),
-        }
-    }
-}
-
-/// Information we keep track of which can be queried by SHOW SERVERS
-#[derive(Debug, Clone)]
-pub struct ServerStats {
-    /// A random integer assigned to the server and used by stats to track the server
-    server_id: i32,
-
-    /// Context information, only to be read
-    address: Address,
-    connect_time: Instant,
-
-    pool_stats: Arc<PoolStats>,
-    reporter: Reporter,
-
-    /// Data
-    pub application_name: Arc<RwLock<String>>,
-    pub state: Arc<AtomicServerState>,
-    pub bytes_sent: Arc<AtomicU64>,
-    pub bytes_received: Arc<AtomicU64>,
-    pub transaction_count: Arc<AtomicU64>,
-    pub query_count: Arc<AtomicU64>,
-    pub error_count: Arc<AtomicU64>,
-}
-
-impl Default for ServerStats {
-    fn default() -> Self {
-        ServerStats {
-            server_id: 0,
-            application_name: Arc::new(RwLock::new(String::new())),
-            address: Address::default(),
-            pool_stats: Arc::new(PoolStats::default()),
-            connect_time: Instant::now(),
-            state: Arc::new(AtomicServerState::new(ServerState::Login)),
-            bytes_sent: Arc::new(AtomicU64::new(0)),
-            bytes_received: Arc::new(AtomicU64::new(0)),
-            transaction_count: Arc::new(AtomicU64::new(0)),
-            query_count: Arc::new(AtomicU64::new(0)),
-            error_count: Arc::new(AtomicU64::new(0)),
-            reporter: get_reporter(),
-        }
-    }
-}
-
-impl ServerStats {
-    pub fn new(address: Address, pool_stats: Arc<PoolStats>, connect_time: Instant) -> Self {
-        Self {
-            address,
-            pool_stats,
-            connect_time,
-            server_id: rand::random::<i32>(),
-            ..Default::default()
-        }
-    }
-
-    pub fn server_id(&self) -> i32 {
-        self.server_id
-    }
-
-    /// Register a server connection with the stats system. The stats system uses server_id
-    /// to track and aggregate statistics from all source that relate to that server
-    // Delegates to reporter
-    pub fn register(&self, stats: Arc<ServerStats>) {
-        self.reporter.server_register(self.server_id, stats);
-        self.login();
-    }
-
-    /// Reports a server connection is no longer assigned to a client
-    /// and is available for the next client to pick it up
-    pub fn idle(&self) {
-        self.pool_stats
-            .server_idle(self.state.load(Ordering::Relaxed));
-
-        self.state.store(ServerState::Idle, Ordering::Relaxed);
-    }
-
-    /// Reports a server connection is disconnecting from the pooler.
-    /// Also updates metrics on the pool regarding server usage.
-    pub fn disconnect(&self) {
-        self.reporter.server_disconnecting(self.server_id);
-        self.pool_stats
-            .server_disconnect(self.state.load(Ordering::Relaxed))
-    }
-
-    /// Reports a server connection is being tested before being given to a client.
-    pub fn tested(&self) {
-        self.set_undefined_application();
-        self.pool_stats
-            .server_tested(self.state.load(Ordering::Relaxed));
-        self.state.store(ServerState::Tested, Ordering::Relaxed);
-    }
-
-    /// Reports a server connection is attempting to login.
-    pub fn login(&self) {
-        self.pool_stats
-            .server_login(self.state.load(Ordering::Relaxed));
-        self.state.store(ServerState::Login, Ordering::Relaxed);
-        self.set_undefined_application();
-    }
-
-    /// Reports a server connection has been assigned to a client that
-    /// is about to query the server
-    pub fn active(&self, application_name: String) {
-        self.pool_stats
-            .server_active(self.state.load(Ordering::Relaxed));
-        self.state.store(ServerState::Active, Ordering::Relaxed);
-        self.set_application(application_name);
-    }
-
-    pub fn address_stats(&self) -> Arc<AddressStats> {
-        self.address.stats.clone()
-    }
-
-    // Helper methods for show_servers
-    pub fn pool_name(&self) -> String {
-        self.pool_stats.database()
-    }
-
-    pub fn username(&self) -> String {
-        self.pool_stats.user()
-    }
-
-    pub fn address_name(&self) -> String {
-        self.address.name()
-    }
-
-    pub fn connect_time(&self) -> Instant {
-        self.connect_time
-    }
-
-    fn set_application(&self, name: String) {
-        let mut application_name = self.application_name.write();
-        *application_name = name;
-    }
-
-    fn set_undefined_application(&self) {
-        self.set_application(String::from("Undefined"))
-    }
-
-    pub fn checkout_time(&self, microseconds: u64, application_name: String) {
-        // Update server stats and address aggergation stats
-        self.set_application(application_name);
-        self.address
-            .stats
-            .total_wait_time
-            .fetch_add(microseconds, Ordering::Relaxed);
-        self.pool_stats
-            .maxwait
-            .fetch_max(microseconds, Ordering::Relaxed);
-    }
-
-    /// Report a query executed by a client against a server
-    pub fn query(&self, milliseconds: u64, application_name: &str) {
-        self.set_application(application_name.to_string());
-        let address_stats = self.address_stats();
-        address_stats
-            .total_query_count
-            .fetch_add(1, Ordering::Relaxed);
-        address_stats
-            .total_query_time
-            .fetch_add(milliseconds, Ordering::Relaxed);
-    }
-
-    /// Report a transaction executed by a client a server
-    /// we report each individual queries outside a transaction as a transaction
-    /// We only count the initial BEGIN as a transaction, all queries within do not
-    /// count as transactions
-    pub fn transaction(&self, application_name: &str) {
-        self.set_application(application_name.to_string());
-
-        self.transaction_count.fetch_add(1, Ordering::Relaxed);
-        self.address
-            .stats
-            .total_xact_count
-            .fetch_add(1, Ordering::Relaxed);
-    }
-
-    /// Report data sent to a server
-    pub fn data_sent(&self, amount_bytes: usize) {
-        self.bytes_sent
-            .fetch_add(amount_bytes as u64, Ordering::Relaxed);
-        self.address
-            .stats
-            .total_sent
-            .fetch_add(amount_bytes as u64, Ordering::Relaxed);
-    }
-
-    /// Report data received from a server
-    pub fn data_received(&self, amount_bytes: usize) {
-        self.bytes_received
-            .fetch_add(amount_bytes as u64, Ordering::Relaxed);
-        self.address
-            .stats
-            .total_received
-            .fetch_add(amount_bytes as u64, Ordering::Relaxed);
-    }
-}
--- a/tests/docker/docker-compose.yml
+++ b/tests/docker/docker-compose.yml
@@ -36,15 +36,6 @@ services:
      POSTGRES_PASSWORD: postgres
      POSTGRES_INITDB_ARGS: --auth-local=scram-sha-256 --auth-host=scram-sha-256 --auth=scram-sha-256
    command: ["postgres", "-p", "9432", "-c", "shared_preload_libraries=pg_stat_statements", "-c", "pg_stat_statements.track=all", "-c", "pg_stat_statements.max=100000"]
-  pg5:
-    image: postgres:14
-    network_mode: "service:main"
-    environment:
-      POSTGRES_USER: postgres
-      POSTGRES_DB: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_INITDB_ARGS: --auth-local=md5 --auth-host=md5 --auth=md5
-    command: ["postgres", "-c", "shared_preload_libraries=pg_stat_statements", "-c", "pg_stat_statements.track=all", "-p", "10432"]
  main:
    build: .
    command: ["bash", "/app/tests/docker/run.sh"]
--- a/tests/python/async_test.py
+++ b/tests/python/async_test.py
@@ -1,60 +0,0 @@
-import psycopg2
-import asyncio
-import asyncpg
-
-PGCAT_HOST = "127.0.0.1"
-PGCAT_PORT = "6432"
-
-
-def regular_main():
-    # Connect to the PostgreSQL database
-    conn = psycopg2.connect(
-        host=PGCAT_HOST,
-        database="sharded_db",
-        user="sharding_user",
-        password="sharding_user",
-        port=PGCAT_PORT,
-    )
-
-    # Open a cursor to perform database operations
-    cur = conn.cursor()
-
-    # Execute a SQL query
-    cur.execute("SELECT 1")
-
-    # Fetch the results
-    rows = cur.fetchall()
-
-    # Print the results
-    for row in rows:
-        print(row[0])
-
-    # Close the cursor and the database connection
-    cur.close()
-    conn.close()
-
-
-async def main():
-    # Connect to the PostgreSQL database
-    conn = await asyncpg.connect(
-        host=PGCAT_HOST,
-        database="sharded_db",
-        user="sharding_user",
-        password="sharding_user",
-        port=PGCAT_PORT,
-    )
-
-    # Execute a SQL query
-    for _ in range(25):
-        rows = await conn.fetch("SELECT 1")
-
-        # Print the results
-        for row in rows:
-            print(row[0])
-
-    # Close the database connection
-    await conn.close()
-
-
-regular_main()
-asyncio.run(main())
--- a/tests/python/requirements.txt
+++ b/tests/python/requirements.txt
@@ -1,11 +1,2 @@
-asyncio==3.4.3
-asyncpg==0.27.0
-black==23.3.0
-click==8.1.3
-mypy-extensions==1.0.0
-packaging==23.1
-pathspec==0.11.1
-platformdirs==3.2.0
-psutil==5.9.1
 psycopg2==2.9.3
-tomli==2.0.1
+psutil==5.9.1
--- a/tests/ruby/admin_spec.rb
+++ b/tests/ruby/admin_spec.rb
@@ -37,9 +37,9 @@ describe "Admin" do
  describe "SHOW POOLS" do
    context "bad credentials" do
      it "does not change any stats" do
-        bad_password_url = URI(pgcat_conn_str)
-        bad_password_url.password = "wrong"
-        expect { PG::connect("#{bad_password_url.to_s}?application_name=bad_password") }.to raise_error(PG::ConnectionBad)
+        bad_passsword_url = URI(pgcat_conn_str)
+        bad_passsword_url.password = "wrong"
+        expect { PG::connect("#{bad_passsword_url.to_s}?application_name=bad_password") }.to raise_error(PG::ConnectionBad)

        sleep(1)
        admin_conn = PG::connect(processes.pgcat.admin_connection_string)
@@ -176,47 +176,6 @@ describe "Admin" do
      end
    end

-    context "clients connects and disconnect normally" do
-      let(:processes) { Helpers::Pgcat.single_instance_setup("sharded_db", 2) }
-
-      it 'shows the same number of clients before and after' do
-        clients_before = clients_connected_to_pool(processes: processes)
-        threads = []
-        connections = Array.new(4) { PG::connect("#{pgcat_conn_str}?application_name=one_query") }
-        connections.each do |c|
-          threads << Thread.new { c.async_exec("SELECT 1") }
-        end
-        clients_between = clients_connected_to_pool(processes: processes)
-        expect(clients_before).not_to eq(clients_between)
-        connections.each(&:close)
-        clients_after = clients_connected_to_pool(processes: processes)
-        expect(clients_before).to eq(clients_after)
-      end
-    end
-
-    context "clients connects and disconnect abruptly" do
-      let(:processes) { Helpers::Pgcat.single_instance_setup("sharded_db", 10) }
-
-      it 'shows the same number of clients before and after' do
-        threads = []
-        connections = Array.new(2) { PG::connect("#{pgcat_conn_str}?application_name=one_query") }
-        connections.each do |c|
-          threads << Thread.new { c.async_exec("SELECT 1") }
-        end
-        clients_before = clients_connected_to_pool(processes: processes)
-        random_string = (0...8).map { (65 + rand(26)).chr }.join
-        connection_string = "#{pgcat_conn_str}?application_name=#{random_string}"
-        faulty_client = Process.spawn("psql -Atx #{connection_string} >/dev/null")
-        sleep(1)
-        # psql starts two processes, we only know the pid of the parent, this
-        # ensure both are killed
-        `pkill -9 -f '#{random_string}'`
-        Process.wait(faulty_client)
-        clients_after = clients_connected_to_pool(processes: processes)
-        expect(clients_before).to eq(clients_after)
-      end
-    end
-
    context "clients overwhelm server pools" do
      let(:processes) { Helpers::Pgcat.single_instance_setup("sharded_db", 2) }

@@ -240,7 +199,7 @@ describe "Admin" do

        sleep(2.5) # Allow time for stats to update
        results = admin_conn.async_exec("SHOW POOLS")[0]
-        %w[cl_active cl_waiting cl_cancel_req sv_active sv_used sv_tested sv_login].each do |s|
+        %w[cl_active cl_waiting cl_cancel_req sv_active sv_used sv_tested sv_login maxwait].each do |s|
          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
        end
        expect(results["cl_idle"]).to eq("4")
--- a/tests/ruby/auth_query_spec.rb
+++ b/tests/ruby/auth_query_spec.rb
@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'spec_helper'
-require_relative 'helpers/auth_query_helper'
-
-describe "Auth Query" do
-  let(:configured_instances) {[5432, 10432]}
-  let(:config_user) { { 'username' => 'sharding_user', 'password' => 'sharding_user' } }
-  let(:pg_user) { { 'username' => 'sharding_user', 'password' => 'sharding_user' } }
-  let(:processes) { Helpers::AuthQuery.single_shard_auth_query(pool_name: "sharded_db", pg_user: pg_user, config_user: config_user, extra_conf: config, wait_until_ready: wait_until_ready ) }
-  let(:config) { {} }
-  let(:wait_until_ready) { true }
-
-  after do
-    unless @failing_process
-      processes.all_databases.map(&:reset)
-      processes.pgcat.shutdown
-    end
-    @failing_process = false
-  end
-
-  context "when auth_query is not configured" do
-    context 'and cleartext passwords are set' do
-      it "uses local passwords" do
-        conn = PG.connect(processes.pgcat.connection_string("sharded_db", config_user['username'], config_user['password']))
-
-        expect(conn.async_exec("SELECT 1 + 2")).not_to be_nil
-      end
-    end
-
-    context 'and cleartext passwords are not set' do
-      let(:config_user) { { 'username' => 'sharding_user' } }
-
-      it "does not start because it is not possible to authenticate" do
-        @failing_process = true
-        expect { processes.pgcat }.to raise_error(StandardError, /You have to specify a user password for every pool if auth_query is not specified/)
-      end
-    end
-  end
-
-  context 'when auth_query is configured' do
-    context 'with global configuration' do
-      around(:example) do |example|
-
-        # Set up auth query
-        Helpers::AuthQuery.set_up_auth_query_for_user(
-          user: 'md5_auth_user',
-          password: 'secret'
-        );
-
-        example.run
-
-        # Drop auth query support
-        Helpers::AuthQuery.tear_down_auth_query_for_user(
-          user: 'md5_auth_user',
-          password: 'secret'
-        );
-      end
-
-      context 'with correct global parameters' do
-        let(:config) { { 'general' => { 'auth_query' => "SELECT * FROM public.user_lookup('$1');", 'auth_query_user' => 'md5_auth_user', 'auth_query_password' => 'secret' } } }
-        context 'and with cleartext passwords set' do
-          it 'it uses local passwords' do
-            conn = PG.connect(processes.pgcat.connection_string("sharded_db", pg_user['username'], pg_user['password']))
-            expect(conn.exec("SELECT 1 + 2")).not_to be_nil
-          end
-        end
-
-        context 'and with cleartext passwords not set' do
-          let(:config_user) { { 'username' => 'sharding_user', 'password' => 'sharding_user' } }
-
-          it 'it uses obtained passwords' do
-            connection_string = processes.pgcat.connection_string("sharded_db", pg_user['username'], pg_user['password'])
-            conn = PG.connect(connection_string)
-            expect(conn.async_exec("SELECT 1 + 2")).not_to be_nil
-          end
-
-          it 'allows passwords to be changed without closing existing connections' do
-            pgconn = PG.connect(processes.pgcat.connection_string("sharded_db", pg_user['username']))
-            expect(pgconn.exec("SELECT 1 + 2")).not_to be_nil
-            Helpers::AuthQuery.exec_in_instances(query: "ALTER USER #{pg_user['username']} WITH ENCRYPTED PASSWORD 'secret2';")
-            expect(pgconn.exec("SELECT 1 + 4")).not_to be_nil
-            Helpers::AuthQuery.exec_in_instances(query: "ALTER USER #{pg_user['username']} WITH ENCRYPTED PASSWORD '#{pg_user['password']}';")
-          end
-
-          it 'allows passwords to be changed and that new password is needed when reconnecting' do
-            pgconn = PG.connect(processes.pgcat.connection_string("sharded_db", pg_user['username']))
-            expect(pgconn.exec("SELECT 1 + 2")).not_to be_nil
-            Helpers::AuthQuery.exec_in_instances(query: "ALTER USER #{pg_user['username']} WITH ENCRYPTED PASSWORD 'secret2';")
-            newconn = PG.connect(processes.pgcat.connection_string("sharded_db", pg_user['username'], 'secret2'))
-            expect(newconn.exec("SELECT 1 + 2")).not_to be_nil
-            Helpers::AuthQuery.exec_in_instances(query: "ALTER USER #{pg_user['username']} WITH ENCRYPTED PASSWORD '#{pg_user['password']}';")
-          end
-        end
-      end
-
-      context 'with wrong parameters' do
-        let(:config) { { 'general' => { 'auth_query' => 'SELECT 1', 'auth_query_user' => 'wrong_user', 'auth_query_password' => 'wrong' } } }
-
-        context 'and with clear text passwords set' do
-          it "it uses local passwords" do
-            conn = PG.connect(processes.pgcat.connection_string("sharded_db", pg_user['username'], pg_user['password']))
-
-            expect(conn.async_exec("SELECT 1 + 2")).not_to be_nil
-          end
-        end
-
-        context 'and with cleartext passwords not set' do
-          let(:config_user) { { 'username' => 'sharding_user' } }
-          it "it fails to start as it cannot authenticate against servers" do
-            @failing_process = true
-            expect { PG.connect(processes.pgcat.connection_string("sharded_db", pg_user['username'], pg_user['password'])) }.to raise_error(StandardError, /Error trying to obtain password from auth_query/ )
-          end
-
-          context 'and we fix the issue and reload' do
-            let(:wait_until_ready) { false }
-
-            it 'fails in the beginning but starts working after reloading config' do
-              connection_string = processes.pgcat.connection_string("sharded_db", pg_user['username'], pg_user['password'])
-              while !(processes.pgcat.logs =~ /Waiting for clients/) do
-                sleep 0.5
-              end
-
-              expect { PG.connect(connection_string)}.to raise_error(PG::ConnectionBad)
-              expect(processes.pgcat.logs).to match(/Error trying to obtain password from auth_query/)
-
-              current_config = processes.pgcat.current_config
-              config = { 'general' => { 'auth_query' => "SELECT * FROM public.user_lookup('$1');", 'auth_query_user' => 'md5_auth_user', 'auth_query_password' => 'secret' } }
-              processes.pgcat.update_config(current_config.deep_merge(config))
-              processes.pgcat.reload_config
-
-              conn = nil
-              expect { conn = PG.connect(connection_string)}.not_to raise_error
-              expect(conn.async_exec("SELECT 1 + 2")).not_to be_nil
-            end
-          end
-        end
-      end
-    end
-
-    context 'with per pool configuration' do
-      around(:example) do |example|
-
-        # Set up auth query
-        Helpers::AuthQuery.set_up_auth_query_for_user(
-          user: 'md5_auth_user',
-          password: 'secret'
-        );
-
-        Helpers::AuthQuery.set_up_auth_query_for_user(
-          user: 'md5_auth_user1',
-          password: 'secret',
-          database: 'shard1'
-        );
-
-        example.run
-
-        # Tear down auth query
-        Helpers::AuthQuery.tear_down_auth_query_for_user(
-          user: 'md5_auth_user',
-          password: 'secret'
-        );
-
-        Helpers::AuthQuery.tear_down_auth_query_for_user(
-          user: 'md5_auth_user1',
-          password: 'secret',
-          database: 'shard1'
-        );
-      end
-
-      context 'with correct parameters' do
-        let(:processes) { Helpers::AuthQuery.two_pools_auth_query(pool_names: ["sharded_db0", "sharded_db1"], pg_user: pg_user, config_user: config_user, extra_conf: config ) }
-        let(:config) {
-          { 'pools' =>
-            {
-              'sharded_db0' => {
-                'auth_query' => "SELECT * FROM public.user_lookup('$1');",
-                'auth_query_user' => 'md5_auth_user',
-                'auth_query_password' => 'secret'
-              },
-              'sharded_db1' => {
-                'auth_query' => "SELECT * FROM public.user_lookup('$1');",
-                'auth_query_user' => 'md5_auth_user1',
-                'auth_query_password' => 'secret'
-              },
-            }
-          }
-        } 
-
-        context 'and with cleartext passwords set' do
-          it 'it uses local passwords' do
-            conn = PG.connect(processes.pgcat.connection_string("sharded_db0", pg_user['username'], pg_user['password']))
-            expect(conn.exec("SELECT 1 + 2")).not_to be_nil
-            conn = PG.connect(processes.pgcat.connection_string("sharded_db1", pg_user['username'], pg_user['password']))
-            expect(conn.exec("SELECT 1 + 2")).not_to be_nil
-          end
-        end
-
-        context 'and with cleartext passwords not set' do
-          let(:config_user) { { 'username' => 'sharding_user' } }
-
-          it 'it uses obtained passwords' do
-            connection_string = processes.pgcat.connection_string("sharded_db0", pg_user['username'], pg_user['password'])
-            conn = PG.connect(connection_string)
-            expect(conn.async_exec("SELECT 1 + 2")).not_to be_nil
-            connection_string = processes.pgcat.connection_string("sharded_db1", pg_user['username'], pg_user['password'])
-            conn = PG.connect(connection_string)
-            expect(conn.async_exec("SELECT 1 + 2")).not_to be_nil
-          end
-        end
-
-      end
-    end
-  end
-end
--- a/tests/ruby/capture
+++ b/tests/ruby/capture
--- a/tests/ruby/helpers/auth_query_helper.rb
+++ b/tests/ruby/helpers/auth_query_helper.rb
@@ -1,173 +0,0 @@
-module Helpers
-  module AuthQuery
-    def self.single_shard_auth_query(
-          pg_user:,
-          config_user:,
-          pool_name:,
-          extra_conf: {},
-          log_level: 'debug',
-          wait_until_ready: true
-        )
-
-      user = {
-        "pool_size" => 10,
-        "statement_timeout" => 0,
-      }
-
-      pgcat = PgcatProcess.new(log_level)
-      pgcat_cfg = pgcat.current_config.deep_merge(extra_conf)
-
-      primary  = PgInstance.new(5432,  pg_user["username"], pg_user["password"], "shard0")
-      replica  = PgInstance.new(10432, pg_user["username"], pg_user["password"], "shard0")
-
-      # Main proxy configs
-      pgcat_cfg["pools"] = {
-        "#{pool_name}" => {
-          "default_role" => "any",
-          "pool_mode" => "transaction",
-          "load_balancing_mode" => "random",
-          "primary_reads_enabled" => false,
-          "query_parser_enabled" => false,
-          "sharding_function" => "pg_bigint_hash",
-          "shards" => {
-            "0" => {
-              "database" => "shard0",
-              "servers" => [
-                ["localhost", primary.port.to_s, "primary"],
-                ["localhost", replica.port.to_s, "replica"],
-              ]
-            },
-          },
-          "users" => { "0" => user.merge(config_user) }
-        }
-      }
-      pgcat_cfg["general"]["port"] = pgcat.port
-      pgcat.update_config(pgcat_cfg)
-      pgcat.start
-      
-      pgcat.wait_until_ready(
-        pgcat.connection_string(
-          "sharded_db",
-          pg_user['username'],
-          pg_user['password']
-        )
-      ) if wait_until_ready
-
-      OpenStruct.new.tap do |struct|
-        struct.pgcat = pgcat
-        struct.primary = primary
-        struct.replicas = [replica]
-        struct.all_databases = [primary]
-      end
-    end
-
-    def self.two_pools_auth_query(
-          pg_user:,
-          config_user:,
-          pool_names:,
-          extra_conf: {},
-          log_level: 'debug'
-        )
-
-      user = {
-        "pool_size" => 10,
-        "statement_timeout" => 0,
-      }
-
-      pgcat = PgcatProcess.new(log_level)
-      pgcat_cfg = pgcat.current_config
-
-      primary  = PgInstance.new(5432,  pg_user["username"], pg_user["password"], "shard0")
-      replica  = PgInstance.new(10432, pg_user["username"], pg_user["password"], "shard0")
-
-      pool_template = Proc.new do |database|
-        {
-          "default_role" => "any",
-          "pool_mode" => "transaction",
-          "load_balancing_mode" => "random",
-          "primary_reads_enabled" => false,
-          "query_parser_enabled" => false,
-          "sharding_function" => "pg_bigint_hash",
-          "shards" => {
-            "0" => {
-              "database" => database,
-              "servers" => [
-                ["localhost", primary.port.to_s, "primary"],
-                ["localhost", replica.port.to_s, "replica"],
-              ]
-            },
-          },
-          "users" => { "0" => user.merge(config_user) }
-        }                                  
-      end
-      # Main proxy configs
-      pgcat_cfg["pools"] = {
-        "#{pool_names[0]}" => pool_template.call("shard0"),
-        "#{pool_names[1]}" => pool_template.call("shard1")
-      }
-
-      pgcat_cfg["general"]["port"] = pgcat.port
-      pgcat.update_config(pgcat_cfg.deep_merge(extra_conf))
-      pgcat.start
-      
-      pgcat.wait_until_ready(pgcat.connection_string("sharded_db0", pg_user['username'], pg_user['password']))
-
-      OpenStruct.new.tap do |struct|
-        struct.pgcat = pgcat
-        struct.primary = primary
-        struct.replicas = [replica]
-        struct.all_databases = [primary]
-      end
-    end
-
-    def self.create_query_auth_function(user)
-      return <<-SQL
-CREATE OR REPLACE FUNCTION public.user_lookup(in i_username text, out uname text, out phash text)
-RETURNS record AS $$
-BEGIN
-    SELECT usename, passwd FROM pg_catalog.pg_shadow
-    WHERE usename = i_username INTO uname, phash;
-    RETURN;
-END;
-$$ LANGUAGE plpgsql SECURITY DEFINER;
-
-GRANT EXECUTE ON FUNCTION public.user_lookup(text) TO #{user};
-SQL
-    end
-
-    def self.exec_in_instances(query:, instance_ports: [ 5432, 10432 ], database: 'postgres', user: 'postgres', password: 'postgres')
-      instance_ports.each do |port|
-        c = PG.connect("postgres://#{user}:#{password}@localhost:#{port}/#{database}")
-        c.exec(query)
-        c.close
-      end
-    end
-
-    def self.set_up_auth_query_for_user(user:, password:, instance_ports: [ 5432, 10432 ], database: 'shard0' )
-      instance_ports.each do |port|
-        connection = PG.connect("postgres://postgres:postgres@localhost:#{port}/#{database}")
-        connection.exec(self.drop_query_auth_function(user)) rescue PG::UndefinedFunction
-        connection.exec("DROP ROLE #{user}") rescue PG::UndefinedObject
-        connection.exec("CREATE ROLE #{user} ENCRYPTED PASSWORD '#{password}' LOGIN;")
-        connection.exec(self.create_query_auth_function(user))
-        connection.close
-      end
-    end
-
-    def self.tear_down_auth_query_for_user(user:, password:, instance_ports: [ 5432, 10432 ], database: 'shard0' )
-      instance_ports.each do |port|
-        connection = PG.connect("postgres://postgres:postgres@localhost:#{port}/#{database}")
-        connection.exec(self.drop_query_auth_function(user)) rescue PG::UndefinedFunction
-        connection.exec("DROP ROLE #{user}")
-        connection.close
-      end
-    end
-
-    def self.drop_query_auth_function(user)
-      return <<-SQL
-REVOKE ALL ON FUNCTION public.user_lookup(text) FROM public, #{user};
-DROP FUNCTION public.user_lookup(in i_username text, out uname text, out phash text);
-SQL
-    end
-  end
-end
--- a/tests/ruby/helpers/pg_socket.rb
+++ b/tests/ruby/helpers/pg_socket.rb
@@ -1,259 +0,0 @@
-require 'socket'
-require 'digest/md5'
-
-BACKEND_MESSAGE_CODES = {
-  'Z' => "ReadyForQuery",
-  'C' => "CommandComplete",
-  'T' => "RowDescription",
-  'D' => "DataRow",
-  '1' => "ParseComplete",
-  '2' => "BindComplete",
-  'E' => "ErrorResponse",
-  's' => "PortalSuspended",
-}
-
-class PostgresSocket
-  def initialize(host, port)
-    @port = port
-    @host = host
-    @socket = TCPSocket.new @host, @port
-    @parameters = {}
-    @verbose = true
-  end
-
-  def send_md5_password_message(username, password, salt)
-    m = Digest::MD5.hexdigest(password + username)
-    m = Digest::MD5.hexdigest(m + salt.map(&:chr).join(""))
-    m = 'md5' + m
-    bytes = (m.split("").map(&:ord) + [0]).flatten
-    message_size = bytes.count + 4
-
-    message = []
-
-    message << 'p'.ord
-    message << [message_size].pack('l>').unpack('CCCC') # 4
-    message << bytes
-    message.flatten!
-
-
-    @socket.write(message.pack('C*'))
-  end
-
-  def send_startup_message(username, database, password)
-    message = []
-
-    message << [196608].pack('l>').unpack('CCCC') # 4
-    message << "user".split('').map(&:ord) # 4, 8
-    message << 0 # 1, 9
-    message << username.split('').map(&:ord) # 2, 11
-    message << 0 # 1, 12
-    message << "database".split('').map(&:ord) # 8, 20
-    message << 0 # 1, 21
-    message << database.split('').map(&:ord) # 2, 23
-    message << 0 # 1, 24
-    message << 0 # 1, 25
-    message.flatten!
-
-    total_message_size = message.size + 4
-
-    message_len = [total_message_size].pack('l>').unpack('CCCC')
-
-    @socket.write([message_len + message].flatten.pack('C*'))
-
-    sleep 0.1
-
-    read_startup_response(username, password)
-  end
-
-  def read_startup_response(username, password)
-    message_code, message_len = @socket.recv(5).unpack("al>")
-    while message_code == 'R'
-      auth_code = @socket.recv(4).unpack('l>').pop
-      case auth_code
-      when 5 # md5
-        salt = @socket.recv(4).unpack('CCCC')
-        send_md5_password_message(username, password, salt)
-        message_code, message_len = @socket.recv(5).unpack("al>")
-      when 0 # trust
-        break
-      end
-    end
-    loop do
-      message_code, message_len = @socket.recv(5).unpack("al>")
-      if message_code == 'Z'
-        @socket.recv(1).unpack("a") # most likely I
-        break # We are good to go
-      end
-      if message_code == 'S'
-        actual_message = @socket.recv(message_len - 4).unpack("C*")
-        k,v = actual_message.pack('U*').split(/\x00/)
-        @parameters[k] = v
-      end
-      if message_code == 'K'
-        process_id, secret_key = @socket.recv(message_len - 4).unpack("l>l>")
-        @parameters["process_id"] = process_id
-        @parameters["secret_key"] = secret_key
-      end
-    end
-    return @parameters
-  end
-
-  def cancel_query
-    socket = TCPSocket.new @host, @port
-    process_key = @parameters["process_id"]
-    secret_key =  @parameters["secret_key"]
-    message = []
-    message << [16].pack('l>').unpack('CCCC') # 4
-    message << [80877102].pack('l>').unpack('CCCC') # 4
-    message << [process_key.to_i].pack('l>').unpack('CCCC') # 4
-    message << [secret_key.to_i].pack('l>').unpack('CCCC') # 4
-    message.flatten!
-    socket.write(message.flatten.pack('C*'))
-    socket.close
-    log "[F] Sent CancelRequest message"
-  end
-
-  def send_query_message(query)
-    query_size = query.length
-    message_size = 1 + 4 + query_size
-    message = []
-    message << "Q".ord
-    message << [message_size].pack('l>').unpack('CCCC') # 4
-    message << query.split('').map(&:ord) # 2, 11
-    message << 0 # 1, 12
-    message.flatten!
-    @socket.write(message.flatten.pack('C*'))
-    log "[F] Sent Q message (#{query})"
-  end
-
-  def send_parse_message(query)
-    query_size = query.length
-    message_size = 2 + 2 + 4 + query_size
-    message = []
-    message << "P".ord
-    message << [message_size].pack('l>').unpack('CCCC') # 4
-    message << 0 # unnamed statement
-    message << query.split('').map(&:ord) # 2, 11
-    message << 0 # 1, 12
-    message << [0, 0]
-    message.flatten!
-    @socket.write(message.flatten.pack('C*'))
-    log "[F] Sent P message (#{query})"
-  end
-
-  def send_bind_message
-    message = []
-    message << "B".ord
-    message << [12].pack('l>').unpack('CCCC') # 4
-    message << 0 # unnamed statement
-    message << 0 # unnamed statement
-    message << [0, 0] # 2
-    message << [0, 0] # 2
-    message << [0, 0] # 2
-    message.flatten!
-    @socket.write(message.flatten.pack('C*'))
-    log "[F] Sent B message"
-  end
-
-  def send_describe_message(mode)
-    message = []
-    message << "D".ord
-    message << [6].pack('l>').unpack('CCCC') # 4
-    message << mode.ord
-    message << 0 # unnamed statement
-    message.flatten!
-    @socket.write(message.flatten.pack('C*'))
-    log "[F] Sent D message"
-  end
-
-  def send_execute_message(limit=0)
-    message = []
-    message << "E".ord
-    message << [9].pack('l>').unpack('CCCC') # 4
-    message << 0 # unnamed statement
-    message << [limit].pack('l>').unpack('CCCC') # 4
-    message.flatten!
-    @socket.write(message.flatten.pack('C*'))
-    log "[F] Sent E message"
-  end
-
-  def send_sync_message
-    message = []
-    message << "S".ord
-    message << [4].pack('l>').unpack('CCCC') # 4
-    message.flatten!
-    @socket.write(message.flatten.pack('C*'))
-    log "[F] Sent S message"
-  end
-
-  def send_copydone_message
-    message = []
-    message << "c".ord
-    message << [4].pack('l>').unpack('CCCC') # 4
-    message.flatten!
-    @socket.write(message.flatten.pack('C*'))
-    log "[F] Sent c message"
-  end
-
-  def send_copyfail_message
-    message = []
-    message << "f".ord
-    message << [5].pack('l>').unpack('CCCC') # 4
-    message << 0
-    message.flatten!
-    @socket.write(message.flatten.pack('C*'))
-    log "[F] Sent f message"
-  end
-
-  def send_flush_message
-    message = []
-    message << "H".ord
-    message << [4].pack('l>').unpack('CCCC') # 4
-    message.flatten!
-    @socket.write(message.flatten.pack('C*'))
-    log "[F] Sent H message"
-  end
-
-  def read_from_server()
-    output_messages = []
-    retry_count = 0
-    message_code = nil
-    message_len = 0
-    loop do
-      begin
-        message_code, message_len = @socket.recv_nonblock(5).unpack("al>")
-      rescue IO::WaitReadable
-        return output_messages if retry_count > 50
-
-        retry_count += 1
-        sleep(0.01)
-        next
-      end
-      message = {
-        code: message_code,
-        len: message_len,
-        bytes: []
-      }
-      log "[B] #{BACKEND_MESSAGE_CODES[message_code] || ('UnknownMessage(' + message_code + ')')}"
-
-      actual_message_length = message_len - 4
-      if actual_message_length > 0
-        message[:bytes] = @socket.recv(message_len - 4).unpack("C*")
-        log "\t#{message[:bytes].join(",")}"
-        log "\t#{message[:bytes].map(&:chr).join(" ")}"
-      end
-      output_messages << message
-      return output_messages if message_code == 'Z'
-    end
-  end
-
-  def log(msg)
-    return unless @verbose
-
-    puts msg
-  end
-
-  def close
-    @socket.close
-  end
-end
--- a/tests/ruby/helpers/pgcat_helper.rb
+++ b/tests/ruby/helpers/pgcat_helper.rb
@@ -2,14 +2,6 @@ require 'json'
 require 'ostruct'
 require_relative 'pgcat_process'
 require_relative 'pg_instance'
-require_relative 'pg_socket'
-
-class ::Hash
-    def deep_merge(second)
-        merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-        self.merge(second, &merger)
-    end
-end

 module Helpers
  module Pgcat
--- a/tests/ruby/helpers/pgcat_process.rb
+++ b/tests/ruby/helpers/pgcat_process.rb
@@ -67,21 +67,17 @@ class PgcatProcess
  def start
    raise StandardError, "Process is already started" unless @pid.nil?
    @pid = Process.spawn(@env, @command, err: @log_filename, out: @log_filename)
-    Process.detach(@pid)
    ObjectSpace.define_finalizer(@log_filename, proc { PgcatProcess.finalize(@pid, @log_filename, @config_filename) })

    return self
  end

-  def wait_until_ready(connection_string = nil)
+  def wait_until_ready
    exc = nil
    10.times do
-      Process.kill 0, @pid
-      PG::connect(connection_string || example_connection_string).close
+      PG::connect(example_connection_string).close

      return self
-    rescue Errno::ESRCH
-      raise StandardError, "Process #{@pid} died. #{logs}"
    rescue => e
      exc = e
      sleep(0.5)
@@ -112,10 +108,13 @@ class PgcatProcess
    "postgresql://#{username}:#{password}@0.0.0.0:#{@port}/pgcat"
  end

-  def connection_string(pool_name, username, password = nil)
+  def connection_string(pool_name, username)
    cfg = current_config
+
    user_idx, user_obj = cfg["pools"][pool_name]["users"].detect { |k, user| user["username"] == username }
-    "postgresql://#{username}:#{password || user_obj["password"]}@0.0.0.0:#{@port}/#{pool_name}"
+    password = user_obj["password"]
+
+    "postgresql://#{username}:#{password}@0.0.0.0:#{@port}/#{pool_name}"
  end

  def example_connection_string
--- a/tests/ruby/load_balancing_spec.rb
+++ b/tests/ruby/load_balancing_spec.rb
@@ -65,7 +65,7 @@ describe "Least Outstanding Queries Load Balancing" do
    processes.pgcat.shutdown
  end

-  context "under homogeneous load" do
+  context "under homogenous load" do
    it "balances query volume between all instances" do
      conn = PG.connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))

--- a/tests/ruby/misc_spec.rb
+++ b/tests/ruby/misc_spec.rb
@@ -309,58 +309,4 @@ describe "Miscellaneous" do
      end
    end
  end
-
-  describe "Idle client timeout" do
-    context "idle transaction timeout set to 0" do
-      before do
-        current_configs = processes.pgcat.current_config
-        correct_idle_client_transaction_timeout = current_configs["general"]["idle_client_in_transaction_timeout"]
-        puts(current_configs["general"]["idle_client_in_transaction_timeout"])
-  
-        current_configs["general"]["idle_client_in_transaction_timeout"] = 0
-  
-        processes.pgcat.update_config(current_configs) # with timeout 0
-        processes.pgcat.reload_config
-      end
-
-      it "Allow client to be idle in transaction" do
-        conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-        conn.async_exec("BEGIN")
-        conn.async_exec("SELECT 1")
-        sleep(2)
-        conn.async_exec("COMMIT")
-        conn.close
-      end
-    end
-
-    context "idle transaction timeout set to 500ms" do
-      before do
-        current_configs = processes.pgcat.current_config
-        correct_idle_client_transaction_timeout = current_configs["general"]["idle_client_in_transaction_timeout"]  
-        current_configs["general"]["idle_client_in_transaction_timeout"] = 500
-  
-        processes.pgcat.update_config(current_configs) # with timeout 500
-        processes.pgcat.reload_config
-      end
-
-      it "Allow client to be idle in transaction below timeout" do
-        conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-        conn.async_exec("BEGIN")
-        conn.async_exec("SELECT 1")
-        sleep(0.4) # below 500ms
-        conn.async_exec("COMMIT")
-        conn.close
-      end
-
-      it "Error when client idle in transaction time exceeds timeout" do
-        conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-        conn.async_exec("BEGIN")
-        conn.async_exec("SELECT 1")
-        sleep(1) # above 500ms
-        expect{ conn.async_exec("COMMIT") }.to raise_error(PG::SystemError, /idle transaction timeout/) 
-        conn.async_exec("SELECT 1") # should be able to send another query
-        conn.close
-      end
-    end
-  end
 end
--- a/tests/ruby/protocol_spec.rb
+++ b/tests/ruby/protocol_spec.rb
@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-require_relative 'spec_helper'
-
-
-describe "Portocol handling" do
-  let(:processes) { Helpers::Pgcat.single_instance_setup("sharded_db", 1, "session") }
-  let(:sequence) { [] }
-  let(:pgcat_socket) { PostgresSocket.new('localhost', processes.pgcat.port) }
-  let(:pgdb_socket) { PostgresSocket.new('localhost', processes.all_databases.first.port) }
-
-  after do
-    pgdb_socket.close
-    pgcat_socket.close
-    processes.all_databases.map(&:reset)
-    processes.pgcat.shutdown
-  end
-
-  def run_comparison(sequence, socket_a, socket_b)
-    sequence.each do |msg, *args|
-      socket_a.send(msg, *args)
-      socket_b.send(msg, *args)
-
-      compare_messages(
-        socket_a.read_from_server,
-        socket_b.read_from_server
-      )
-    end
-  end
-
-  def compare_messages(msg_arr0, msg_arr1)
-    if msg_arr0.count != msg_arr1.count
-      error_output = []
-
-      error_output << "#{msg_arr0.count} : #{msg_arr1.count}"
-      error_output << "PgCat Messages"
-      error_output += msg_arr0.map { |message| "\t#{message[:code]} - #{message[:bytes].map(&:chr).join(" ")}" }
-      error_output << "PgServer Messages"
-      error_output += msg_arr1.map { |message| "\t#{message[:code]} - #{message[:bytes].map(&:chr).join(" ")}" }
-      error_desc = error_output.join("\n")
-      raise StandardError, "Message count mismatch #{error_desc}"
-    end
-
-    (0..msg_arr0.count - 1).all? do |i|
-      msg0 = msg_arr0[i]
-      msg1 = msg_arr1[i]
-
-      result = [
-        msg0[:code] == msg1[:code],
-        msg0[:len] == msg1[:len],
-        msg0[:bytes] == msg1[:bytes],
-      ].all?
-
-      next result if result
-
-      if result == false
-        error_string = []
-        if msg0[:code] != msg1[:code]
-          error_string << "code #{msg0[:code]} != #{msg1[:code]}"
-        end
-        if msg0[:len] != msg1[:len]
-          error_string << "len #{msg0[:len]} != #{msg1[:len]}"
-        end
-        if msg0[:bytes] != msg1[:bytes]
-          error_string << "bytes #{msg0[:bytes]} != #{msg1[:bytes]}"
-        end
-        err = error_string.join("\n")
-
-        raise StandardError, "Message mismatch #{err}"
-      end
-    end
-  end
-
-  RSpec.shared_examples "at parity with database" do
-    before do
-      pgcat_socket.send_startup_message("sharding_user", "sharded_db", "sharding_user")
-      pgdb_socket.send_startup_message("sharding_user", "shard0", "sharding_user")
-    end
-
-    it "works" do
-      run_comparison(sequence, pgcat_socket, pgdb_socket)
-    end
-  end
-
-  context "Cancel Query" do
-    let(:sequence) {
-      [
-        [:send_query_message, "SELECT pg_sleep(5)"],
-        [:cancel_query]
-      ]
-    }
-
-    it_behaves_like "at parity with database"
-  end
-
-  xcontext "Simple query after parse" do
-    let(:sequence) {
-      [
-        [:send_parse_message, "SELECT 5"],
-        [:send_query_message, "SELECT 1"],
-        [:send_bind_message],
-        [:send_describe_message, "P"],
-        [:send_execute_message],
-        [:send_sync_message],
-      ]
-    }
-
-    # Known to fail due to PgCat not supporting flush
-    it_behaves_like "at parity with database"
-  end
-
-  xcontext "Flush message" do
-    let(:sequence) {
-      [
-        [:send_parse_message, "SELECT 1"],
-        [:send_flush_message]
-      ]
-    }
-
-    # Known to fail due to PgCat not supporting flush
-    it_behaves_like "at parity with database"
-  end
-
-  xcontext "Bind without parse" do
-    let(:sequence) {
-      [
-        [:send_bind_message]
-      ]
-    }
-    # This is known to fail.
-    # Server responds immediately, Proxy buffers the message
-    it_behaves_like "at parity with database"
-  end
-
-  context "Simple message" do
-    let(:sequence) {
-      [[:send_query_message, "SELECT 1"]]
-    }
-
-    it_behaves_like "at parity with database"
-  end
-
-  context "Extended protocol" do
-    let(:sequence) {
-      [
-        [:send_parse_message, "SELECT 1"],
-        [:send_bind_message],
-        [:send_describe_message, "P"],
-        [:send_execute_message],
-        [:send_sync_message],
-      ]
-    }
-
-    it_behaves_like "at parity with database"
-  end
-end
--- a/tests/ruby/sharding_spec.rb
+++ b/tests/ruby/sharding_spec.rb
@@ -27,7 +27,7 @@ describe "Sharding" do
    processes.pgcat.shutdown
  end

-  describe "automatic routing of extended protocol" do
+  describe "automatic routing of extended procotol" do
    it "can do it" do
      conn = PG.connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
      conn.exec("SET SERVER ROLE TO 'auto'")
--- a/tests/ruby/spec_helper.rb
+++ b/tests/ruby/spec_helper.rb
@@ -19,10 +19,3 @@ ensure
  STDOUT.reopen(sout)
  STDERR.reopen(serr)
 end
-
-def clients_connected_to_pool(pool_index: 0, processes:)
-  admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-  results = admin_conn.async_exec("SHOW POOLS")[pool_index]
-  admin_conn.close
-  results['cl_idle'].to_i + results['cl_active'].to_i + results['cl_waiting'].to_i
-end
--- a/utilities/requirements.txt
+++ b/utilities/requirements.txt
@@ -1 +0,0 @@
-tomli