Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

refactor(gateways): rename setupRelayServer to setupGatewayProxy

bernie-g3805b9e19b84
diff --git a/backend/src/ee/services/pam-web-access/pam-web-access-service.ts b/backend/src/ee/services/pam-web-access/pam-web-access-service.ts
index d0ed5164b6..9963e50152 100644
--- a/backend/src/ee/services/pam-web-access/pam-web-access-service.ts
+++ b/backend/src/ee/services/pam-web-access/pam-web-access-service.ts
@@ -13,7 +13,7 @@ import { TPermissionServiceFactory } from "@app/ee/services/permission/permissio
import { ResourcePermissionPamResourceActions } from "@app/ee/services/permission/resource-permission";
import { BadRequestError, ForbiddenRequestError, NotFoundError } from "@app/lib/errors";
import { GatewayProxyProtocol } from "@app/lib/gateway/types";
-import { setupRelayServer, withGatewayV2Proxy } from "@app/lib/gateway-v2/gateway-v2";
+import { setupGatewayProxy, withGatewayV2Proxy } from "@app/lib/gateway-v2/gateway-v2";
import { logger } from "@app/lib/logger";
import { ActorType } from "@app/services/auth/auth-type";
import { TAuthTokenServiceFactory } from "@app/services/auth-token/auth-token-service";
@@ -326,7 +326,7 @@ export const pamWebAccessServiceFactory = ({
let session: { id: string; accountId?: string | null } | null = null;
let cleanedUp = false;
let handlerResult: TSessionHandlerResult | null = null;
- let relayServer: { port: number; cleanup: () => Promise<void> } | null = null;
+ let proxyServer: { port: number; cleanup: () => Promise<void> } | null = null;
let relayCerts: TGatewayV2ConnectionDetails | null = null;
let expiryTimer: ReturnType<typeof setTimeout> | null = null;
let pingInterval: ReturnType<typeof setInterval> | null = null;
@@ -356,13 +356,13 @@ export const pamWebAccessServiceFactory = ({
}
}
- if (relayServer) {
+ if (proxyServer) {
try {
- await relayServer.cleanup();
+ await proxyServer.cleanup();
} catch (err) {
logger.debug(err, "Error closing relay server");
} finally {
- relayServer = null;
+ proxyServer = null;
}
}
@@ -554,7 +554,7 @@ export const pamWebAccessServiceFactory = ({
return {
certs: attemptCerts,
- server: await setupRelayServer({
+ server: await setupGatewayProxy({
protocol: isRdp ? GatewayProxyProtocol.PamRdpBrowser : GatewayProxyProtocol.Pam,
...attemptCerts,
longLived: true,
@@ -565,7 +565,7 @@ export const pamWebAccessServiceFactory = ({
);
const { certs } = attempt.result;
- relayServer = attempt.result.server;
+ proxyServer = attempt.result.server;
// The tunnel is open from here rather than from whenever the session handler first dials, so
// a socket that closed during setup has to be caught: its "close" fired before the listener
@@ -594,7 +594,7 @@ export const pamWebAccessServiceFactory = ({
const ctx: TSessionContext = {
socket,
- relayPort: relayServer.port,
+ relayPort: proxyServer.port,
resourceName: account.name,
sessionId: session.id,
sendMessage: boundSendMessage,
diff --git a/backend/src/lib/gateway-v2/gateway-retry.test.ts b/backend/src/lib/gateway-v2/gateway-retry.test.ts
index de2a28e02a..dd2c9ec6df 100644
--- a/backend/src/lib/gateway-v2/gateway-retry.test.ts
+++ b/backend/src/lib/gateway-v2/gateway-retry.test.ts
@@ -4,25 +4,25 @@ const RELAY_ERR = "TLS connection error: ECONNREFUSED";
describe("isGatewayTransportFailure", () => {
test("retryable when a channel failed to come up and none ever did", () => {
- expect(isGatewayTransportFailure({ relayError: RELAY_ERR, establishedChannel: false })).toBe(true);
+ expect(isGatewayTransportFailure({ transportError: RELAY_ERR, establishedChannel: false })).toBe(true);
});
test("not retryable once a channel came up, even with a relay error recorded", () => {
- // The bug this guards: relayError accumulates across every channel a proxy serves and is never
+ // The bug this guards: transportError accumulates across every channel a proxy serves and is never
// cleared, so one transient setup blip would otherwise mark a later target-side failure (a
// half-applied rotation) as safe to replay on another member.
- expect(isGatewayTransportFailure({ relayError: RELAY_ERR, establishedChannel: true })).toBe(false);
+ expect(isGatewayTransportFailure({ transportError: RELAY_ERR, establishedChannel: true })).toBe(false);
});
test("not retryable with no relay error at all", () => {
- expect(isGatewayTransportFailure({ relayError: "", establishedChannel: false })).toBe(false);
- expect(isGatewayTransportFailure({ relayError: "", establishedChannel: true })).toBe(false);
+ expect(isGatewayTransportFailure({ transportError: "", establishedChannel: false })).toBe(false);
+ expect(isGatewayTransportFailure({ transportError: "", establishedChannel: true })).toBe(false);
});
test("several accumulated relay errors are still only retryable if nothing established", () => {
const many = [RELAY_ERR, RELAY_ERR].join(",");
- expect(isGatewayTransportFailure({ relayError: many, establishedChannel: false })).toBe(true);
- expect(isGatewayTransportFailure({ relayError: many, establishedChannel: true })).toBe(false);
+ expect(isGatewayTransportFailure({ transportError: many, establishedChannel: false })).toBe(true);
+ expect(isGatewayTransportFailure({ transportError: many, establishedChannel: true })).toBe(false);
});
});
diff --git a/backend/src/lib/gateway-v2/gateway-retry.ts b/backend/src/lib/gateway-v2/gateway-retry.ts
index 5b7c068c2d..86c5b536de 100644
--- a/backend/src/lib/gateway-v2/gateway-retry.ts
+++ b/backend/src/lib/gateway-v2/gateway-retry.ts
@@ -3,14 +3,14 @@
* member would apply twice.
*/
-/** `relayError` is never cleared, so requiring that no channel established is what bounds it. */
+/** `transportError` is never cleared, so requiring that no channel established is what bounds it. */
export const isGatewayTransportFailure = ({
- relayError,
+ transportError,
establishedChannel
}: {
- relayError: string;
+ transportError: string;
establishedChannel: boolean;
-}): boolean => Boolean(relayError) && !establishedChannel;
+}): boolean => Boolean(transportError) && !establishedChannel;
/** An early tunnel can fail while a later one reaches the target, so a transport failure alone is not enough. */
export const isAttemptRetryable = ({
diff --git a/backend/src/lib/gateway-v2/gateway-v2.test.ts b/backend/src/lib/gateway-v2/gateway-v2.test.ts
index 82fd3e20fb..601c7eb183 100644
--- a/backend/src/lib/gateway-v2/gateway-v2.test.ts
+++ b/backend/src/lib/gateway-v2/gateway-v2.test.ts
@@ -5,7 +5,7 @@ import forge from "node-forge";
import { GatewayProxyProtocol } from "@app/lib/gateway/types";
-import { setupRelayServer } from "./gateway-v2";
+import { setupGatewayProxy } from "./gateway-v2";
const tracker = vi.hoisted(() => ({
channelOpened: vi.fn(),
@@ -195,7 +195,7 @@ const waitFor = async (predicate: () => boolean) => {
// can leak a release into the next test's counters.
const drainChannels = (count: number) => waitFor(() => tracker.channelClosed.mock.calls.length === count);
-describe("setupRelayServer", () => {
+describe("setupGatewayProxy", () => {
beforeEach(() => {
tracker.channelOpened.mockClear();
tracker.channelClosed.mockClear();
@@ -213,25 +213,25 @@ describe("setupRelayServer", () => {
};
test("resolves when not eager, because the dial is deferred to the first client", async () => {
- const server = await setupRelayServer(args);
+ const server = await setupGatewayProxy(args);
expect(server.port).toBeGreaterThan(0);
expect(server.hasEstablishedChannel()).toBe(false);
await server.cleanup();
});
test("rejects when eager, which is what gives pool failover something to catch", async () => {
- await expect(setupRelayServer({ ...args, eager: true })).rejects.toThrow();
+ await expect(setupGatewayProxy({ ...args, eager: true })).rejects.toThrow();
});
test("reports the failure as a transport error, so it is safe to retry elsewhere", async () => {
- await expect(setupRelayServer({ ...args, eager: true })).rejects.toMatchObject({
+ await expect(setupGatewayProxy({ ...args, eager: true })).rejects.toMatchObject({
name: "BadRequest",
gatewayId: GATEWAY_ID
});
});
test("counts no channel for a tunnel that never opened", async () => {
- await expect(setupRelayServer({ ...args, eager: true })).rejects.toThrow();
+ await expect(setupGatewayProxy({ ...args, eager: true })).rejects.toThrow();
expect(tracker.channelOpened).not.toHaveBeenCalled();
expect(tracker.markSuspect).toHaveBeenCalledWith(GATEWAY_ID);
});
@@ -249,14 +249,14 @@ describe("setupRelayServer", () => {
});
test("does not touch the gateway until a client connects when not eager", async () => {
- const server = await setupRelayServer(argsFor(relay.relayHost));
+ const server = await setupGatewayProxy(argsFor(relay.relayHost));
expect(relay.tunnelsOpened()).toBe(0);
expect(server.hasEstablishedChannel()).toBe(false);
await server.cleanup();
});
test("opens the tunnel during setup when eager", async () => {
- const server = await setupRelayServer({ ...argsFor(relay.relayHost), eager: true, longLived: true });
+ const server = await setupGatewayProxy({ ...argsFor(relay.relayHost), eager: true, longLived: true });
await waitFor(() => relay.tunnelsOpened() === 1);
expect(server.hasEstablishedChannel()).toBe(true);
expect(tracker.channelOpened).toHaveBeenCalledTimes(1);
@@ -266,7 +266,7 @@ describe("setupRelayServer", () => {
});
test("hands the tunnel it already opened to the first client instead of dialing again", async () => {
- const server = await setupRelayServer({ ...argsFor(relay.relayHost), eager: true, longLived: true });
+ const server = await setupGatewayProxy({ ...argsFor(relay.relayHost), eager: true, longLived: true });
await waitFor(() => relay.tunnelsOpened() === 1);
// The reused tunnel has to still carry traffic; a probe-and-drop would fail here.
@@ -279,7 +279,7 @@ describe("setupRelayServer", () => {
});
test("dials a fresh tunnel for the second client", async () => {
- const server = await setupRelayServer({ ...argsFor(relay.relayHost), eager: true, longLived: true });
+ const server = await setupGatewayProxy({ ...argsFor(relay.relayHost), eager: true, longLived: true });
await expect(connectAndEcho(server.port)).resolves.toBe("ping");
await expect(connectAndEcho(server.port)).resolves.toBe("ping");
@@ -292,7 +292,7 @@ describe("setupRelayServer", () => {
});
test("releases the tunnel and its channel count when no client ever claims it", async () => {
- const server = await setupRelayServer({ ...argsFor(relay.relayHost), eager: true, longLived: true });
+ const server = await setupGatewayProxy({ ...argsFor(relay.relayHost), eager: true, longLived: true });
await waitFor(() => relay.tunnelsOpened() === 1);
await server.cleanup();
@@ -302,7 +302,7 @@ describe("setupRelayServer", () => {
});
test("releases the channel count once when a claimed tunnel closes", async () => {
- const server = await setupRelayServer({ ...argsFor(relay.relayHost), eager: true, longLived: true });
+ const server = await setupGatewayProxy({ ...argsFor(relay.relayHost), eager: true, longLived: true });
await expect(connectAndEcho(server.port)).resolves.toBe("ping");
await server.cleanup();
diff --git a/backend/src/lib/gateway-v2/gateway-v2.ts b/backend/src/lib/gateway-v2/gateway-v2.ts
index dbe3ce7e59..185f9abb7d 100644
--- a/backend/src/lib/gateway-v2/gateway-v2.ts
+++ b/backend/src/lib/gateway-v2/gateway-v2.ts
@@ -20,27 +20,27 @@ import { markAttemptTransportFailure, markAttemptTunnelEstablished } from "./gat
import { getGatewayLoadTracker } from "./gateway-load-tracker";
import { isGatewayTransportFailure } from "./gateway-retry";
-interface IGatewayRelayServer {
+interface IGatewayProxyServer {
server: net.Server;
port: number;
cleanup: () => Promise<void>;
- getRelayError: () => string;
+ getTransportError: () => string;
hasEstablishedChannel: () => boolean;
}
const DEFAULT_RELAY_CONNECTION_TIMEOUT_MS = 100000;
/**
- * A gateway tunnel is TLS inside TLS: `gatewayConn` is a TLSSocket whose transport is `relayConn`,
+ * A gateway tunnel is TLS inside TLS: `gatewayConn` is a TLSSocket whose transport is `transportConn`,
* itself a TLSSocket. Tear the two down innermost-first.
*/
export const destroyGatewayTunnel = ({
- relayConn,
+ transportConn,
gatewayConn,
tunnelId,
trigger
}: {
- relayConn?: net.Socket | null;
+ transportConn?: net.Socket | null;
gatewayConn?: net.Socket | null;
/** Correlates the teardown with the tunnel's other lifecycle lines. */
tunnelId?: string;
@@ -52,13 +52,13 @@ export const destroyGatewayTunnel = ({
// from OpenSSL's stack.
if (tunnelId) {
logger.info(
- `gatewayTunnel: teardown scheduled [tunnelId=${tunnelId}] [trigger=${trigger ?? "unknown"}] [gatewayDestroyed=${Boolean(gatewayConn?.destroyed)}] [relayDestroyed=${Boolean(relayConn?.destroyed)}]`
+ `gatewayTunnel: teardown scheduled [tunnelId=${tunnelId}] [trigger=${trigger ?? "unknown"}] [gatewayDestroyed=${Boolean(gatewayConn?.destroyed)}] [transportDestroyed=${Boolean(transportConn?.destroyed)}]`
);
}
setImmediate(() => {
gatewayConn?.destroy();
- relayConn?.destroy();
+ transportConn?.destroy();
if (tunnelId) {
logger.info(`gatewayTunnel: teardown complete [tunnelId=${tunnelId}] [trigger=${trigger ?? "unknown"}]`);
}
@@ -131,7 +131,7 @@ const GATEWAY_IDLE_TIMEOUT_MS = 120000;
const DIRECT_HANDSHAKE_TIMEOUT_MS = 3000;
export const createGatewayConnection = async (
- relayConn: net.Socket,
+ transportConn: net.Socket,
gateway: { clientCertificate: string; clientPrivateKey: string; serverCertificateChain: string },
protocol: GatewayProxyProtocol,
tunnelId?: string,
@@ -159,7 +159,7 @@ export const createGatewayConnection = async (
const isIpLiteral = Boolean(net.isIP(serverName));
const tlsOptions: tls.ConnectionOptions = {
- socket: relayConn,
+ socket: transportConn,
cert: gateway.clientCertificate,
key: gateway.clientPrivateKey,
ca: splitPemChain(gateway.serverCertificateChain),
@@ -176,7 +176,7 @@ export const createGatewayConnection = async (
try {
// These listeners outlive the handshake, so each one has to stay correct once the tunnel is
// established: destroying is always deferred, and reject() is a no-op on a settled promise.
- // Callers respond to a rejection by scheduling relayConn's destroy, which lands on the same
+ // Callers respond to a rejection by scheduling transportConn's destroy, which lands on the same
// queue behind ours, so the inner socket still goes first.
const gatewaySocket = tls.connect(tlsOptions, () => {
if (!gatewaySocket.authorized) {
@@ -211,7 +211,7 @@ export const createGatewayConnection = async (
});
};
-export const setupRelayServer = async ({
+export const setupGatewayProxy = async ({
gatewayId,
protocol,
directAddress,
@@ -236,8 +236,8 @@ export const setupRelayServer = async ({
* gateway sees one channel that becomes the session.
*/
eager?: boolean;
-}): Promise<IGatewayRelayServer> => {
- const relayErrorMsg: string[] = [];
+}): Promise<IGatewayProxyServer> => {
+ const transportErrors: string[] = [];
let establishedChannel = false;
const loadTracker = getGatewayLoadTracker();
let localPort = 0;
@@ -248,7 +248,7 @@ export const setupRelayServer = async ({
type TUpstream = {
tunnelId: string;
- relayConn: net.Socket;
+ transportConn: net.Socket;
gatewayConn: net.Socket;
releaseChannel: () => void;
};
@@ -293,17 +293,17 @@ export const setupRelayServer = async ({
serverName,
direct ? DIRECT_HANDSHAKE_TIMEOUT_MS : undefined
);
- return { relayConn: conn, gatewayConn: gwConn };
+ return { transportConn: conn, gatewayConn: gwConn };
} catch (err) {
- destroyGatewayTunnel({ relayConn: conn, tunnelId, trigger: "gatewayHandshakeFailed" });
+ destroyGatewayTunnel({ transportConn: conn, tunnelId, trigger: "gatewayHandshakeFailed" });
throw err;
}
};
- let relayConn: net.Socket;
+ let transportConn: net.Socket;
let gatewayConn: net.Socket;
try {
- ({ relayConn, gatewayConn } = await openOverTransport(directAddress ? dialDirect : dialRelay));
+ ({ transportConn, gatewayConn } = await openOverTransport(directAddress ? dialDirect : dialRelay));
} catch (err) {
const reason = err instanceof Error ? err.message : String(err);
tunnelLog(tunnelId, directAddress ? "direct transport failed" : "relay transport failed", ` [err=${reason}]`);
@@ -311,7 +311,7 @@ export const setupRelayServer = async ({
tunnelLog(tunnelId, "falling back to relay");
try {
- ({ relayConn, gatewayConn } = await openOverTransport(dialRelay));
+ ({ transportConn, gatewayConn } = await openOverTransport(dialRelay));
} catch (relayErr) {
tunnelLog(
tunnelId,
@@ -322,11 +322,13 @@ export const setupRelayServer = async ({
}
}
- relayConn.on("close", (hadError: boolean) => tunnelLog(tunnelId, "relay socket close", ` [hadError=${hadError}]`));
+ transportConn.on("close", (hadError: boolean) =>
+ tunnelLog(tunnelId, "transport socket close", ` [hadError=${hadError}]`)
+ );
gatewayConn.on("close", (hadError: boolean) =>
tunnelLog(tunnelId, "gateway socket close", ` [hadError=${hadError}]`)
);
- relayConn.on("error", (err: Error) => tunnelLog(tunnelId, "relay socket error", ` [err=${err.message}]`));
+ transportConn.on("error", (err: Error) => tunnelLog(tunnelId, "transport socket error", ` [err=${err.message}]`));
gatewayConn.on("error", (err: Error) => tunnelLog(tunnelId, "gateway socket error", ` [err=${err.message}]`));
// The gateway dials the target the moment it accepts the channel, so from here the attempt is
@@ -337,12 +339,12 @@ export const setupRelayServer = async ({
if (longLived) {
// Drop the inactivity timeout applied after the handshake. Without this, an idle session is
// destroyed once it goes quiet for GATEWAY_IDLE_TIMEOUT_MS.
- relayConn.setTimeout(0);
+ transportConn.setTimeout(0);
gatewayConn.setTimeout(0);
// Enable TCP keep-alive probes every 30s to detect dead connections
// without terminating idle-but-alive ones.
- relayConn.setKeepAlive(true, 30000);
+ transportConn.setKeepAlive(true, 30000);
gatewayConn.setKeepAlive(true, 30000);
}
@@ -374,7 +376,7 @@ export const setupRelayServer = async ({
return {
tunnelId,
- relayConn,
+ transportConn,
gatewayConn,
releaseChannel: () => {
if (released) return;
@@ -389,10 +391,10 @@ export const setupRelayServer = async ({
const discardPendingUpstream = () => {
if (!pendingUpstream) return;
- const { tunnelId, relayConn, gatewayConn, releaseChannel } = pendingUpstream;
+ const { tunnelId, transportConn, gatewayConn, releaseChannel } = pendingUpstream;
pendingUpstream = null;
releaseChannel();
- destroyGatewayTunnel({ relayConn, gatewayConn, tunnelId, trigger: "discardUnclaimed" });
+ destroyGatewayTunnel({ transportConn, gatewayConn, tunnelId, trigger: "discardUnclaimed" });
};
return new Promise((resolve, reject) => {
@@ -406,14 +408,14 @@ export const setupRelayServer = async ({
const claimed = pendingUpstream;
pendingUpstream = null;
- const { tunnelId, relayConn, gatewayConn, releaseChannel } = claimed ?? (await openUpstream());
+ const { tunnelId, transportConn, gatewayConn, releaseChannel } = claimed ?? (await openUpstream());
tunnelLog(tunnelId, claimed ? "claimed pre-opened tunnel" : "opened tunnel for client");
// Its "close" already fired, so the teardown listeners below would never run and the
// channel would stay counted for the life of the pod.
if (clientConn.destroyed) {
releaseChannel();
- destroyGatewayTunnel({ relayConn, gatewayConn, tunnelId, trigger: "clientAlreadyGone" });
+ destroyGatewayTunnel({ transportConn, gatewayConn, tunnelId, trigger: "clientAlreadyGone" });
return;
}
@@ -426,11 +428,11 @@ export const setupRelayServer = async ({
tunnelLog(tunnelId, "teardown triggered", ` [trigger=${trigger}]`);
releaseChannel();
clientConn.destroy();
- destroyGatewayTunnel({ relayConn, gatewayConn, tunnelId, trigger });
+ destroyGatewayTunnel({ transportConn, gatewayConn, tunnelId, trigger });
};
clientConn.on("error", (err: Error) => destroyAll(`clientError:${err.message}`));
- relayConn.on("error", () => destroyAll("relayError"));
+ transportConn.on("error", () => destroyAll("transportError"));
gatewayConn.on("error", () => destroyAll("gatewayError"));
// Bidirectional data forwarding
@@ -438,11 +440,11 @@ export const setupRelayServer = async ({
gatewayConn.pipe(clientConn);
clientConn.on("close", () => destroyAll("clientClose"));
- relayConn.on("close", () => destroyAll("relayClose"));
+ transportConn.on("close", () => destroyAll("transportClose"));
gatewayConn.on("close", () => destroyAll("gatewayClose"));
} catch (err) {
const errorMsg = err instanceof Error ? err.message : String(err);
- relayErrorMsg.push(errorMsg);
+ transportErrors.push(errorMsg);
clientConn.destroy();
}
})();
@@ -462,7 +464,7 @@ export const setupRelayServer = async ({
}
localPort = address.port;
- const relayServer: IGatewayRelayServer = {
+ const proxyServer: IGatewayProxyServer = {
server,
port: address.port,
cleanup: async () => {
@@ -473,12 +475,12 @@ export const setupRelayServer = async ({
logger.debug("Error closing server:", err instanceof Error ? err.message : String(err));
}
},
- getRelayError: () => relayErrorMsg.join(","),
+ getTransportError: () => transportErrors.join(","),
hasEstablishedChannel: () => establishedChannel
};
if (!eager) {
- resolve(relayServer);
+ resolve(proxyServer);
return;
}
@@ -492,14 +494,14 @@ export const setupRelayServer = async ({
const dropIfUnclaimed = () => {
if (pendingUpstream === upstream) discardPendingUpstream();
};
- upstream.relayConn.once("close", dropIfUnclaimed);
+ upstream.transportConn.once("close", dropIfUnclaimed);
upstream.gatewayConn.once("close", dropIfUnclaimed);
- upstream.relayConn.once("error", dropIfUnclaimed);
+ upstream.transportConn.once("error", dropIfUnclaimed);
upstream.gatewayConn.once("error", dropIfUnclaimed);
- resolve(relayServer);
+ resolve(proxyServer);
} catch (err) {
- await relayServer.cleanup();
+ await proxyServer.cleanup();
markAttemptTransportFailure();
await getGatewayLoadTracker()?.markSuspect(gatewayId);
reject(
@@ -525,9 +527,9 @@ export const withGatewayV2Proxy = async <T>(
): Promise<T> => {
const { gatewayId, protocol, directAddress, relayHost, gateway, relay, httpsAgent, longLived } = options;
- let relayServer;
+ let proxyServer;
try {
- relayServer = await setupRelayServer({
+ proxyServer = await setupGatewayProxy({
gatewayId,
protocol,
directAddress,
@@ -546,23 +548,25 @@ export const withGatewayV2Proxy = async <T>(
});
}
- const { port, cleanup, getRelayError, hasEstablishedChannel } = relayServer;
+ const { port, cleanup, getTransportError, hasEstablishedChannel } = proxyServer;
try {
// Execute the callback with the allocated port
return await callback(port);
} catch (err) {
- const relayErrorMessage = getRelayError();
- if (relayErrorMessage) {
- logger.error("Relay error:", relayErrorMessage);
+ const transportErrorMessage = getTransportError();
+ if (transportErrorMessage) {
+ logger.error("Relay error:", transportErrorMessage);
}
logger.error("Gateway error:", err instanceof Error ? err.message : String(err));
- let errorMessage = relayErrorMessage || (err instanceof Error ? err.message : String(err));
+ let errorMessage = transportErrorMessage || (err instanceof Error ? err.message : String(err));
if (isAxiosError(err) && (err.response?.data as { message?: string })?.message) {
errorMessage = (err.response?.data as { message: string }).message;
}
- if (isGatewayTransportFailure({ relayError: relayErrorMessage, establishedChannel: hasEstablishedChannel() })) {
+ if (
+ isGatewayTransportFailure({ transportError: transportErrorMessage, establishedChannel: hasEstablishedChannel() })
+ ) {
markAttemptTransportFailure();
await getGatewayLoadTracker()?.markSuspect(gatewayId);
throw new GatewayTransportError({ message: errorMessage, gatewayId });