Log information about proxy-related environment variables

mbg · mbg · commit 33e2dff08237 · 2026-02-17T12:38:30.000Z
diff --git a/lib/start-proxy-action.js b/lib/start-proxy-action.js
diff --git a/src/languages.ts b/src/languages.ts
@@ -23,4 +23,6 @@ export enum KnownLanguage {
 /** Java-specific environment variable names that we may care about. */
 export enum JavaEnvVars {
   JAVA_TOOL_OPTIONS = "JAVA_TOOL_OPTIONS",
+  JDK_JAVA_OPTIONS = "JDK_JAVA_OPTIONS",
+  _JAVA_OPTIONS = "_JAVA_OPTIONS",
 }
diff --git a/src/start-proxy-action.ts b/src/start-proxy-action.ts
@@ -22,6 +22,7 @@ import {
   ProxyConfig,
 } from "./start-proxy";
 import { generateCertificateAuthority } from "./start-proxy/ca";
+import { checkProxyEnvironment } from "./start-proxy/environment";
 import { checkConnections } from "./start-proxy/reachability";
 import { ActionName, sendUnhandledErrorStatusReport } from "./status-report";
 import * as util from "./util";
@@ -76,6 +77,9 @@ async function run(startedAt: Date) {
         .join("\n")}`,
     );
 
+    // Check the environment for any configurations which may affect the proxy.
+    checkProxyEnvironment(logger, language);
+
     const ca = generateCertificateAuthority(
       await features.getValue(Feature.ImprovedProxyCertificates),
     );
diff --git a/src/start-proxy/environment.test.ts b/src/start-proxy/environment.test.ts
@@ -0,0 +1,111 @@
+import test, { ExecutionContext } from "ava";
+
+import { JavaEnvVars, KnownLanguage } from "../languages";
+import {
+  checkExpectedLogMessages,
+  getRecordingLogger,
+  LoggedMessage,
+  setupTests,
+} from "../testing-utils";
+
+import {
+  checkJavaEnvVars,
+  checkProxyEnvironment,
+  checkProxyEnvVars,
+  JAVA_PROXY_ENV_VARS,
+  ProxyEnvVars,
+} from "./environment";
+
+setupTests(test);
+
+function assertEnvVarLogMessages(
+  t: ExecutionContext<any>,
+  envVars: string[],
+  messages: LoggedMessage[],
+  expectSet: boolean,
+) {
+  const template = (envVar: string) =>
+    expectSet
+      ? `Environment variable '${envVar}' is set to '${envVar}'`
+      : `Environment variable '${envVar}' is not set`;
+
+  const expected: string[] = [];
+
+  for (const envVar of envVars) {
+    expected.push(template(envVar));
+  }
+
+  checkExpectedLogMessages(t, messages, expected);
+}
+
+test("checkJavaEnvironment - none set", (t) => {
+  const messages: LoggedMessage[] = [];
+  const logger = getRecordingLogger(messages);
+
+  checkJavaEnvVars(logger);
+  assertEnvVarLogMessages(t, JAVA_PROXY_ENV_VARS, messages, false);
+});
+
+test("checkJavaEnvironment - logs values when variables are set", (t) => {
+  const messages: LoggedMessage[] = [];
+  const logger = getRecordingLogger(messages);
+
+  for (const envVar of Object.values(JavaEnvVars)) {
+    process.env[envVar] = envVar;
+  }
+
+  checkJavaEnvVars(logger);
+  assertEnvVarLogMessages(t, JAVA_PROXY_ENV_VARS, messages, true);
+});
+
+test("checkProxyEnvVars - none set", (t) => {
+  const messages: LoggedMessage[] = [];
+  const logger = getRecordingLogger(messages);
+
+  checkProxyEnvVars(logger);
+  assertEnvVarLogMessages(t, Object.values(ProxyEnvVars), messages, false);
+});
+
+test("checkProxyEnvVars - logs values when variables are set", (t) => {
+  const messages: LoggedMessage[] = [];
+  const logger = getRecordingLogger(messages);
+
+  for (const envVar of Object.values(ProxyEnvVars)) {
+    process.env[envVar] = envVar;
+  }
+
+  for (const envVar of Object.values(ProxyEnvVars)) {
+    process.env[envVar] = envVar;
+  }
+
+  checkProxyEnvVars(logger);
+  assertEnvVarLogMessages(t, Object.values(ProxyEnvVars), messages, true);
+});
+
+test("checkProxyEnvironment - includes base checks for all known languages", (t) => {
+  for (const language of Object.values(KnownLanguage)) {
+    const messages: LoggedMessage[] = [];
+    const logger = getRecordingLogger(messages);
+
+    checkProxyEnvironment(logger, language);
+    assertEnvVarLogMessages(t, Object.keys(ProxyEnvVars), messages, false);
+  }
+});
+
+test("checkProxyEnvironment - includes Java checks for Java", (t) => {
+  const messages: LoggedMessage[] = [];
+  const logger = getRecordingLogger(messages);
+
+  checkProxyEnvironment(logger, KnownLanguage.java);
+  assertEnvVarLogMessages(t, Object.keys(ProxyEnvVars), messages, false);
+  assertEnvVarLogMessages(t, JAVA_PROXY_ENV_VARS, messages, false);
+});
+
+test("checkProxyEnvironment - includes language-specific checks if the language is undefined", (t) => {
+  const messages: LoggedMessage[] = [];
+  const logger = getRecordingLogger(messages);
+
+  checkProxyEnvironment(logger, undefined);
+  assertEnvVarLogMessages(t, Object.keys(ProxyEnvVars), messages, false);
+  assertEnvVarLogMessages(t, JAVA_PROXY_ENV_VARS, messages, false);
+});
diff --git a/src/start-proxy/environment.ts b/src/start-proxy/environment.ts
@@ -0,0 +1,78 @@
+import { JavaEnvVars, KnownLanguage, Language } from "../languages";
+import { Logger } from "../logging";
+import { isDefined } from "../util";
+
+/**
+ * Checks whether an environment variable named `name` is set and logs its value if set.
+ *
+ * @param logger The logger to use.
+ * @param name The name of the environment variable.
+ * @returns True if set or false otherwise.
+ */
+function checkEnvVar(logger: Logger, name: string): boolean {
+  const value = process.env[name];
+  if (isDefined(value)) {
+    logger.info(`Environment variable '${name}' is set to '${value}'.`);
+    return true;
+  } else {
+    logger.debug(`Environment variable '${name}' is not set.`);
+    return false;
+  }
+}
+
+/** Java-specific environment variables which may contain information about proxy settings. */
+export const JAVA_PROXY_ENV_VARS: JavaEnvVars[] = [
+  JavaEnvVars.JAVA_TOOL_OPTIONS,
+  JavaEnvVars.JDK_JAVA_OPTIONS,
+  JavaEnvVars._JAVA_OPTIONS,
+];
+
+/**
+ * Checks whether any Java-specific environment variables which may contain proxy
+ * configurations are set and logs their values if so.
+ */
+export function checkJavaEnvVars(logger: Logger) {
+  for (const envVar of JAVA_PROXY_ENV_VARS) {
+    checkEnvVar(logger, envVar);
+  }
+}
+
+/** Enumerates environment variable names which may contain information about proxy settings. */
+export enum ProxyEnvVars {
+  HTTP_PROXY = "HTTP_PROXY",
+  HTTPS_PROXY = "HTTPS_PROXY",
+  ALL_PROXY = "ALL_PROXY",
+}
+
+/**
+ * Checks whether any proxy-related environment variables are set and logs their values if so.
+ */
+export function checkProxyEnvVars(logger: Logger) {
+  // Both upper-case and lower-case variants of these environment variables are used.
+  for (const envVar of Object.values(ProxyEnvVars)) {
+    checkEnvVar(logger, envVar);
+    checkEnvVar(logger, envVar.toLowerCase());
+  }
+}
+
+/**
+ * Inspects environment variables and other configurations on the runner to determine whether
+ * any settings that may affect the operation of the proxy are present. All relevant information
+ * is written to the log.
+ *
+ * @param logger The logger to use.
+ * @param language The enabled language, if known.
+ */
+export function checkProxyEnvironment(
+  logger: Logger,
+  language: Language | undefined,
+) {
+  // Determine whether there is an existing proxy configured.
+  checkProxyEnvVars(logger);
+
+  // Check language-specific configurations. If we don't know the language,
+  // then we perform all checks.
+  if (language === undefined || language === KnownLanguage.java) {
+    checkJavaEnvVars(logger);
+  }
+}

Original file line number	Diff line number	Diff line change
`@@ -23,4 +23,6 @@ export enum KnownLanguage {`
`23`	`23`	`/** Java-specific environment variable names that we may care about. */`
`24`	`24`	`export enum JavaEnvVars {`
`25`	`25`	`JAVA_TOOL_OPTIONS = "JAVA_TOOL_OPTIONS",`
	`26`	`+ JDK_JAVA_OPTIONS = "JDK_JAVA_OPTIONS",`
	`27`	`+ _JAVA_OPTIONS = "_JAVA_OPTIONS",`
`26`	`28`	`}`