ydb-qdrant 4.7.1 → 4.7.2

package/dist/config/env.d.ts

@@ -19,3 +19,6 @@ export declare const SEARCH_MODE: SearchMode;
 export declare const OVERFETCH_MULTIPLIER: number;
 export declare const CLIENT_SIDE_SERIALIZATION_ENABLED: boolean;
 export declare const UPSERT_BATCH_SIZE: number;
+export declare const SESSION_POOL_MIN_SIZE: number;
+export declare const SESSION_POOL_MAX_SIZE: number;
+export declare const SESSION_KEEPALIVE_PERIOD_MS: number;

package/dist/config/env.js

@@ -78,3 +78,12 @@ export const SEARCH_MODE = resolveSearchModeEnv(COLLECTION_STORAGE_MODE);
 export const OVERFETCH_MULTIPLIER = parseIntegerEnv(process.env.YDB_QDRANT_OVERFETCH_MULTIPLIER, 10, { min: 1 });
 export const CLIENT_SIDE_SERIALIZATION_ENABLED = parseBooleanEnv(process.env.YDB_QDRANT_CLIENT_SIDE_SERIALIZATION_ENABLED, false);
 export const UPSERT_BATCH_SIZE = parseIntegerEnv(process.env.YDB_QDRANT_UPSERT_BATCH_SIZE, 100, { min: 1 });
+// Session pool configuration
+const RAW_SESSION_POOL_MIN_SIZE = parseIntegerEnv(process.env.YDB_SESSION_POOL_MIN_SIZE, 5, { min: 1, max: 500 });
+const RAW_SESSION_POOL_MAX_SIZE = parseIntegerEnv(process.env.YDB_SESSION_POOL_MAX_SIZE, 100, { min: 1, max: 500 });
+const NORMALIZED_SESSION_POOL_MIN_SIZE = RAW_SESSION_POOL_MIN_SIZE > RAW_SESSION_POOL_MAX_SIZE
+    ? RAW_SESSION_POOL_MAX_SIZE
+    : RAW_SESSION_POOL_MIN_SIZE;
+export const SESSION_POOL_MIN_SIZE = NORMALIZED_SESSION_POOL_MIN_SIZE;
+export const SESSION_POOL_MAX_SIZE = RAW_SESSION_POOL_MAX_SIZE;
+export const SESSION_KEEPALIVE_PERIOD_MS = parseIntegerEnv(process.env.YDB_SESSION_KEEPALIVE_PERIOD_MS, 5000, { min: 1000, max: 60000 });

package/dist/ydb/client.d.ts

@@ -8,7 +8,19 @@ type DriverConfig = {
     authService?: IAuthService;
 };
 export declare function __setDriverForTests(fake: unknown): void;
+export declare function __setDriverFactoryForTests(factory: ((config: unknown) => unknown) | undefined): void;
+export declare function __resetRefreshStateForTests(): void;
 export declare function configureDriver(config: DriverConfig): void;
 export declare function readyOrThrow(): Promise<void>;
 export declare function withSession<T>(fn: (s: Session) => Promise<T>): Promise<T>;
 export declare function isYdbAvailable(timeoutMs?: number): Promise<boolean>;
+/**
+ * Destroys the current driver and its session pool.
+ * Next call to withSession or readyOrThrow will create a new driver.
+ */
+export declare function destroyDriver(): Promise<void>;
+/**
+ * Destroys the current driver and immediately creates a fresh one.
+ * Use this to recover from session pool exhaustion or zombie sessions.
+ */
+export declare function refreshDriver(): Promise<void>;

package/dist/ydb/client.js

@@ -1,16 +1,72 @@
 import { createRequire } from "module";
-import { YDB_DATABASE, YDB_ENDPOINT } from "../config/env.js";
+import { YDB_DATABASE, YDB_ENDPOINT, SESSION_POOL_MIN_SIZE, SESSION_POOL_MAX_SIZE, SESSION_KEEPALIVE_PERIOD_MS, } from "../config/env.js";
+import { logger } from "../logging/logger.js";
 const require = createRequire(import.meta.url);
 const { Driver, getCredentialsFromEnv, Types, TypedValues, TableDescription, Column, } = require("ydb-sdk");
 export { Types, TypedValues, TableDescription, Column };
 const DRIVER_READY_TIMEOUT_MS = 15000;
 const TABLE_SESSION_TIMEOUT_MS = 20000;
 const YDB_HEALTHCHECK_READY_TIMEOUT_MS = 5000;
+const DRIVER_REFRESH_COOLDOWN_MS = 30000;
 let overrideConfig;
 let driver;
+let lastDriverRefreshAt = 0;
+let driverRefreshInFlight = null;
+// Test-only: allows injecting a mock Driver factory
+let driverFactoryOverride;
+function shouldTriggerDriverRefresh(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const msg = error.message ?? "";
+    if (/No session became available within timeout/i.test(msg)) {
+        return true;
+    }
+    if (/SESSION_POOL_EMPTY|session pool empty/i.test(msg)) {
+        return true;
+    }
+    if (/SessionExpired|SESSION_EXPIRED|session.*expired/i.test(msg)) {
+        return true;
+    }
+    return false;
+}
+async function maybeRefreshDriverOnSessionError(error) {
+    if (!shouldTriggerDriverRefresh(error)) {
+        return;
+    }
+    const now = Date.now();
+    if (now - lastDriverRefreshAt < DRIVER_REFRESH_COOLDOWN_MS) {
+        logger.warn({ lastDriverRefreshAt, cooldownMs: DRIVER_REFRESH_COOLDOWN_MS }, "YDB driver refresh skipped due to cooldown");
+        return;
+    }
+    if (driverRefreshInFlight) {
+        logger.warn({ lastDriverRefreshAt, cooldownMs: DRIVER_REFRESH_COOLDOWN_MS }, "YDB driver refresh already in flight; skipping");
+        return;
+    }
+    lastDriverRefreshAt = now;
+    logger.warn({ err: error }, "YDB session-related error detected; refreshing driver");
+    try {
+        const refreshPromise = refreshDriver();
+        driverRefreshInFlight = refreshPromise;
+        await refreshPromise;
+    }
+    catch (refreshErr) {
+        logger.error({ err: refreshErr }, "YDB driver refresh failed; keeping current driver");
+    }
+    finally {
+        driverRefreshInFlight = null;
+    }
+}
 export function __setDriverForTests(fake) {
     driver = fake;
 }
+export function __setDriverFactoryForTests(factory) {
+    driverFactoryOverride = factory;
+}
+export function __resetRefreshStateForTests() {
+    lastDriverRefreshAt = 0;
+    driverRefreshInFlight = null;
+}
 export function configureDriver(config) {
     if (driver) {
         // Driver already created; keep existing connection settings.
@@ -28,10 +84,23 @@ function getOrCreateDriver() {
             endpoint: overrideConfig?.endpoint ?? YDB_ENDPOINT,
             database: overrideConfig?.database ?? YDB_DATABASE,
         };
-    driver = new Driver({
+    const driverConfig = {
         ...base,
         authService: overrideConfig?.authService ?? getCredentialsFromEnv(),
-    });
+        poolSettings: {
+            minLimit: SESSION_POOL_MIN_SIZE,
+            maxLimit: SESSION_POOL_MAX_SIZE,
+            keepAlivePeriod: SESSION_KEEPALIVE_PERIOD_MS,
+        },
+    };
+    driver = driverFactoryOverride
+        ? driverFactoryOverride(driverConfig)
+        : new Driver(driverConfig);
+    logger.info({
+        poolMinSize: SESSION_POOL_MIN_SIZE,
+        poolMaxSize: SESSION_POOL_MAX_SIZE,
+        keepAlivePeriodMs: SESSION_KEEPALIVE_PERIOD_MS,
+    }, "YDB driver created with session pool settings");
     return driver;
 }
 export async function readyOrThrow() {
@@ -43,7 +112,13 @@ export async function readyOrThrow() {
 }
 export async function withSession(fn) {
     const d = getOrCreateDriver();
-    return await d.tableClient.withSession(fn, TABLE_SESSION_TIMEOUT_MS);
+    try {
+        return await d.tableClient.withSession(fn, TABLE_SESSION_TIMEOUT_MS);
+    }
+    catch (err) {
+        void maybeRefreshDriverOnSessionError(err);
+        throw err;
+    }
 }
 export async function isYdbAvailable(timeoutMs = YDB_HEALTHCHECK_READY_TIMEOUT_MS) {
     const d = getOrCreateDriver();
@@ -54,3 +129,30 @@ export async function isYdbAvailable(timeoutMs = YDB_HEALTHCHECK_READY_TIMEOUT_M
         return false;
     }
 }
+/**
+ * Destroys the current driver and its session pool.
+ * Next call to withSession or readyOrThrow will create a new driver.
+ */
+export async function destroyDriver() {
+    if (!driver) {
+        return;
+    }
+    logger.info("Destroying YDB driver and session pool");
+    try {
+        await driver.destroy();
+    }
+    catch (err) {
+        logger.warn({ err }, "Error during driver destruction (ignored)");
+    }
+    driver = undefined;
+}
+/**
+ * Destroys the current driver and immediately creates a fresh one.
+ * Use this to recover from session pool exhaustion or zombie sessions.
+ */
+export async function refreshDriver() {
+    logger.info("Refreshing YDB driver");
+    await destroyDriver();
+    await readyOrThrow();
+    logger.info("YDB driver refreshed successfully");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ydb-qdrant",
-  "version": "4.7.1",
+  "version": "4.7.2",
   "main": "dist/package/api.js",
   "types": "dist/package/api.d.ts",
   "exports": {