diff --git a/lib/start-proxy-action.js b/lib/start-proxy-action.js
index a46cc4e6f..4ae444afd 100644
--- a/lib/start-proxy-action.js
+++ b/lib/start-proxy-action.js
@@ -121812,6 +121812,46 @@ function generateCertificateAuthority(newCertGenFF) {
   return { cert: pem, key };
 }
 
+// src/start-proxy/environment.ts
+function checkEnvVar(logger, name) {
+  const value = process.env[name];
+  if (isDefined2(value)) {
+    logger.info(`Environment variable '${name}' is set to '${value}'.`);
+    return true;
+  } else {
+    logger.debug(`Environment variable '${name}' is not set.`);
+    return false;
+  }
+}
+var JAVA_PROXY_ENV_VARS = [
+  "JAVA_TOOL_OPTIONS" /* JAVA_TOOL_OPTIONS */,
+  "JDK_JAVA_OPTIONS" /* JDK_JAVA_OPTIONS */,
+  "_JAVA_OPTIONS" /* _JAVA_OPTIONS */
+];
+function checkJavaEnvVars(logger) {
+  for (const envVar of JAVA_PROXY_ENV_VARS) {
+    checkEnvVar(logger, envVar);
+  }
+}
+var ProxyEnvVars = /* @__PURE__ */ ((ProxyEnvVars2) => {
+  ProxyEnvVars2["HTTP_PROXY"] = "HTTP_PROXY";
+  ProxyEnvVars2["HTTPS_PROXY"] = "HTTPS_PROXY";
+  ProxyEnvVars2["ALL_PROXY"] = "ALL_PROXY";
+  return ProxyEnvVars2;
+})(ProxyEnvVars || {});
+function checkProxyEnvVars(logger) {
+  for (const envVar of Object.values(ProxyEnvVars)) {
+    checkEnvVar(logger, envVar);
+    checkEnvVar(logger, envVar.toLowerCase());
+  }
+}
+function checkProxyEnvironment(logger, language) {
+  checkProxyEnvVars(logger);
+  if (language === void 0 || language === "java" /* java */) {
+    checkJavaEnvVars(logger);
+  }
+}
+
 // src/start-proxy/reachability.ts
 var https = __toESM(require("https"));
 var import_https_proxy_agent = __toESM(require_dist2());
@@ -121932,6 +121972,7 @@ async function run(startedAt) {
       `Credentials loaded for the following registries:
  ${credentials.map((c) => credentialToStr(c)).join("\n")}`
     );
+    checkProxyEnvironment(logger, language);
     const ca = generateCertificateAuthority(
       await features.getValue("improved_proxy_certificates" /* ImprovedProxyCertificates */)
     );
diff --git a/src/languages.ts b/src/languages.ts
index 0ee84a173..15d44b09e 100644
--- 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
index b4e65b157..b2f01d2e7 100644
--- 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
new file mode 100644
index 000000000..b453d119f
--- /dev/null
+++ 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
new file mode 100644
index 000000000..c9ad46599
--- /dev/null
+++ 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);
+  }
+}