Allow AWS_LAMBDA_MAX_CONCURRENCY to be one and crash the RIC Otherwise and Version Bump to 2.8.2 (#92)

* Allow AWS_LAMBDA_MAX_CONCURRENCY to be one and crash the RIC Otherwise.

* Version Bump to 2.8.2

---------

Authored-by: Mohammed Ehab <moehabe@amazon.com>

Author: M-Elsaeed

README.md

@@ -163,7 +163,7 @@ The purpose of this package is to allow developers to deploy their applications
 <dependency>
  <groupId>com.amazonaws</groupId>
  <artifactId>aws-lambda-java-runtime-interface-client</artifactId>
- <version>2.8.1</version>
+ <version>2.8.2</version>
 </dependency>
 ```
 

aws-lambda-java-runtime-interface-client/README.md

@@ -70,7 +70,7 @@ pom.xml
     <dependency>
       <groupId>com.amazonaws</groupId>
       <artifactId>aws-lambda-java-runtime-interface-client</artifactId>
-      <version>2.8.1</version>
+      <version>2.8.2</version>
     </dependency>
   </dependencies>
   <build>

aws-lambda-java-runtime-interface-client/RELEASE.CHANGELOG.md

@@ -1,3 +1,7 @@
+### June 26, 2025
+`2.8.2`
+- Allow AWS_LAMBDA_MAX_CONCURRENCY to be One. Crash the RIC if it is set to an un-parsable string to an integer or an out of bounds value.
+
 ### June 26, 2025
 `2.8.1`
 - Refactoring

aws-lambda-java-runtime-interface-client/pom.xml

@@ -4,7 +4,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.amazonaws</groupId>
     <artifactId>aws-lambda-java-runtime-interface-client</artifactId>
-    <version>2.8.1</version>
+    <version>2.8.2</version>
     <packaging>jar</packaging>
 
     <name>AWS Lambda Java Runtime Interface Client</name>

aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/ReservedRuntimeEnvironmentVariables.java

@@ -108,8 +108,8 @@ public interface ReservedRuntimeEnvironmentVariables {
     String TZ = "TZ";
 
     /*
-     * Used to set the required number of concurrent runtime loops, 
-     * If AWS_LAMBDA_MAX_CONCURRENCY is not set, the default number of concurrent runtime loops is the number of cores.
+     * If set to a string parsable as an integer > 0, It enables multiconcurrency mode. 
+     * Otherwise, if it is set to an invalid value, it will crash the whole RIC process.
      */
     String AWS_LAMBDA_MAX_CONCURRENCY = "AWS_LAMBDA_MAX_CONCURRENCY";
 }

aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/util/ConcurrencyConfig.java

@@ -14,6 +14,8 @@
 public class ConcurrencyConfig {
     private static final int AWS_LAMBDA_MAX_CONCURRENCY_LIMIT = 1000;
     private final int numberOfPlatformThreads;
+    private final String INVALID_CONFIG_MESSAGE_PREFIX = String.format("User configured %s is invalid. Please make sure it is a positive number more than zero and less than or equal %d", 
+                                                                        ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY, AWS_LAMBDA_MAX_CONCURRENCY_LIMIT);
 
     public ConcurrencyConfig(LambdaContextLogger logger) {
         this(logger, new EnvReader());
@@ -24,21 +26,16 @@ public ConcurrencyConfig(LambdaContextLogger logger, EnvReader envReader) {
         try {
             String readLambdaMaxConcurrencyEnvVar = envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY);
 
-            // Log only if env var is actually set to an invalid value. Otherwise default to no concurrency silently.
-            if (!(readLambdaMaxConcurrencyEnvVar == null || readLambdaMaxConcurrencyEnvVar.isEmpty())) {
+            if (readLambdaMaxConcurrencyEnvVar != null) {
                 readNumOfPlatformThreads = Integer.parseInt(readLambdaMaxConcurrencyEnvVar);
-                if (readNumOfPlatformThreads <= 0 || readNumOfPlatformThreads > AWS_LAMBDA_MAX_CONCURRENCY_LIMIT) {
+                if (readNumOfPlatformThreads < 1 || readNumOfPlatformThreads > AWS_LAMBDA_MAX_CONCURRENCY_LIMIT) {
                     throw new IllegalArgumentException();
                 }
             }
         } catch (Exception e) {
-            readNumOfPlatformThreads = 0;
-            String message = String.format(
-                    "User configured %s is not valid. Please make sure it is a positive number more than zero and less than or equal %d\n%s\nDefaulting to no concurrency.",
-                    ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY,
-                    AWS_LAMBDA_MAX_CONCURRENCY_LIMIT,
-                    UserFault.trace(e));
-            logger.log(message, logger.getLogFormat() == LogFormat.JSON ? LogLevel.WARN : LogLevel.UNDEFINED);
+            String message = String.format("%s\n%s", INVALID_CONFIG_MESSAGE_PREFIX, UserFault.trace(e));
+            logger.log(message, logger.getLogFormat() == LogFormat.JSON ? LogLevel.ERROR : LogLevel.UNDEFINED);
+            throw e;
         }
 
         this.numberOfPlatformThreads = readNumOfPlatformThreads;
@@ -49,7 +46,7 @@ public String getConcurrencyConfigMessage() {
     }
 
     public boolean isMultiConcurrent() {
-        return this.numberOfPlatformThreads > 1;
+        return this.numberOfPlatformThreads >= 1;
     }
 
     public int getNumberOfPlatformThreads() {

aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/util/ConcurrencyConfigTest.java

@@ -14,8 +14,9 @@
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
+import static org.junit.Assert.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.contains;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.*;
 
@@ -27,6 +28,8 @@ class ConcurrencyConfigTest {
     @Mock
     private EnvReader envReader;
 
+    private static final String exitingRuntimeString = String.format("User configured %s is invalid.", ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY);
+
     @Test
     void testDefaultConfiguration() {
         when(envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY)).thenReturn(null);
@@ -37,35 +40,51 @@ void testDefaultConfiguration() {
         assertEquals(false, config.isMultiConcurrent());
     }
 
+    @Test
+    void testBelowMinPlatformThreadsLimit() {
+        when(lambdaLogger.getLogFormat()).thenReturn(LogFormat.JSON);
+        when(envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY)).thenReturn("0");
+
+        assertThrows(IllegalArgumentException.class, () -> new ConcurrencyConfig(lambdaLogger, envReader));
+        verify(lambdaLogger).log(contains(exitingRuntimeString), eq(LogLevel.ERROR));
+    }
+
+    @Test
+    void testMinValidPlatformThreadsConfig() {
+        when(envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY)).thenReturn("1");
+
+        ConcurrencyConfig config = new ConcurrencyConfig(lambdaLogger, envReader);
+        verifyNoInteractions(lambdaLogger);
+        assertEquals(1, config.getNumberOfPlatformThreads());
+        assertEquals(true, config.isMultiConcurrent());
+    }
+
     @Test
     void testValidPlatformThreadsConfig() {
         when(envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY)).thenReturn("4");
 
         ConcurrencyConfig config = new ConcurrencyConfig(lambdaLogger, envReader);
+        verifyNoInteractions(lambdaLogger);
         assertEquals(4, config.getNumberOfPlatformThreads());
         assertEquals(true, config.isMultiConcurrent());
     }
 
     @Test
-    void testInvalidPlatformThreadsConfig() {
+    void testExceedingPlatformThreadsLimit() {
         when(lambdaLogger.getLogFormat()).thenReturn(LogFormat.JSON);
-        when(envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY)).thenReturn("invalid");
+        when(envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY)).thenReturn("1001");
 
-        ConcurrencyConfig config = new ConcurrencyConfig(lambdaLogger, envReader);
-        assertEquals(0, config.getNumberOfPlatformThreads());
-        verify(lambdaLogger).log(anyString(), eq(LogLevel.WARN));
-        assertEquals(false, config.isMultiConcurrent());
+        assertThrows(IllegalArgumentException.class, () -> new ConcurrencyConfig(lambdaLogger, envReader));
+        verify(lambdaLogger).log(contains(exitingRuntimeString), eq(LogLevel.ERROR));
     }
 
     @Test
-    void testExceedingPlatformThreadsLimit() {
+    void testInvalidPlatformThreadsConfig() {
         when(lambdaLogger.getLogFormat()).thenReturn(LogFormat.JSON);
-        when(envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY)).thenReturn("1001");
+        when(envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY)).thenReturn("invalid");
 
-        ConcurrencyConfig config = new ConcurrencyConfig(lambdaLogger, envReader);
-        assertEquals(0, config.getNumberOfPlatformThreads());
-        verify(lambdaLogger).log(anyString(), eq(LogLevel.WARN));
-        assertEquals(false, config.isMultiConcurrent());
+        assertThrows(NumberFormatException.class, () -> new ConcurrencyConfig(lambdaLogger, envReader));
+        verify(lambdaLogger).log(contains(exitingRuntimeString), eq(LogLevel.ERROR));
     }
 
     @Test
@@ -74,13 +93,15 @@ void testGetConcurrencyConfigMessage() {
 
         ConcurrencyConfig config = new ConcurrencyConfig(lambdaLogger, envReader);
         String expectedMessage = "Starting 4 concurrent function handler threads.";
+        verifyNoInteractions(lambdaLogger);
         assertEquals(expectedMessage, config.getConcurrencyConfigMessage());
         assertEquals(true, config.isMultiConcurrent());
     }
 
     @Test
     void testGetConcurrencyConfigWithNoConcurrency() {
         ConcurrencyConfig config = new ConcurrencyConfig(lambdaLogger, envReader);
+        verifyNoInteractions(lambdaLogger);
         assertEquals(0, config.getNumberOfPlatformThreads());
         assertEquals(false, config.isMultiConcurrent());
     }