Update fork

.github/workflows/nebula-ci.yml

@@ -0,0 +1,50 @@
+name: "CI"
+on:
+  push:
+    branches:
+      - '*'
+    tags-ignore:
+      - '*'
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        # test against JDK 8
+        java: [ 8 ]
+    name: CI with Java ${{ matrix.java }}
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup git user
+        run: |
+          git config --global user.name "Netflix OSS Maintainers"
+          git config --global user.email "netflixoss@netflix.com"
+      - name: Setup jdk
+        uses: actions/setup-java@v5
+        with:
+          java-version: ${{ matrix.java }}
+          distribution: 'zulu'
+      - uses: actions/cache@v5
+        id: gradle-cache
+        with:
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/gradle/dependency-locks/*.lockfile') }}
+          restore-keys: |
+            - ${{ runner.os }}-gradle-
+      - uses: actions/cache@v5
+        id: gradle-wrapper-cache
+        with:
+          path: ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradlewrapper-${{ hashFiles('gradle/wrapper/*') }}
+          restore-keys: |
+            - ${{ runner.os }}-gradlewrapper-
+      - name: Build with Gradle
+        run: ./gradlew --info --stacktrace build
+        env:
+          CI_NAME: github_actions
+          CI_BUILD_NUMBER: ${{ github.sha }}
+          CI_BUILD_URL: 'https://github.com/${{ github.repository }}'
+          CI_BRANCH: ${{ github.ref }}
+          COVERALLS_REPO_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/nebula-publish.yml

@@ -0,0 +1,54 @@
+name: "Publish candidate/release to NetflixOSS and Maven Central"
+on:
+  push:
+    tags:
+      - v*.*.*
+      - v*.*.*-rc.*
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    environment: Publish
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup git user
+        run: |
+          git config --global user.name "Netflix OSS Maintainers"
+          git config --global user.email "netflixoss@netflix.com"
+      - name: Setup jdk 8
+        uses: actions/setup-java@v5
+        with:
+          java-version: 1.8
+          distribution: 'zulu'
+      - uses: actions/cache@v5
+        id: gradle-cache
+        with:
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/gradle/dependency-locks/*.lockfile') }}
+          restore-keys: |
+            - ${{ runner.os }}-gradle-
+      - uses: actions/cache@v5
+        id: gradle-wrapper-cache
+        with:
+          path: ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradlewrapper-${{ hashFiles('gradle/wrapper/*') }}
+          restore-keys: |
+            - ${{ runner.os }}-gradlewrapper-
+      - name: Publish candidate
+        if: contains(github.ref, '-rc.')
+        run: ./gradlew --info --stacktrace -Prelease.useLastTag=true candidate
+        env:
+          NETFLIX_OSS_SIGNING_KEY: ${{ secrets.ORG_SIGNING_KEY }}
+          NETFLIX_OSS_SIGNING_PASSWORD: ${{ secrets.ORG_SIGNING_PASSWORD }}
+          NETFLIX_OSS_REPO_USERNAME: ${{ secrets.ORG_NETFLIXOSS_USERNAME }}
+          NETFLIX_OSS_REPO_PASSWORD: ${{ secrets.ORG_NETFLIXOSS_PASSWORD }}
+      - name: Publish release
+        if: (!contains(github.ref, '-rc.'))
+        run: ./gradlew --info -Prelease.useLastTag=true final
+        env:
+          NETFLIX_OSS_SONATYPE_USERNAME: ${{ secrets.ORG_SONATYPE_USERNAME }}
+          NETFLIX_OSS_SONATYPE_PASSWORD: ${{ secrets.ORG_SONATYPE_PASSWORD }}
+          NETFLIX_OSS_SIGNING_KEY: ${{ secrets.ORG_SIGNING_KEY }}
+          NETFLIX_OSS_SIGNING_PASSWORD: ${{ secrets.ORG_SIGNING_PASSWORD }}
+          NETFLIX_OSS_REPO_USERNAME: ${{ secrets.ORG_NETFLIXOSS_USERNAME }}
+          NETFLIX_OSS_REPO_PASSWORD: ${{ secrets.ORG_NETFLIXOSS_PASSWORD }}

.github/workflows/nebula-snapshot.yml

@@ -0,0 +1,43 @@
+name: "Publish snapshot to NetflixOSS and Maven Central"
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    environment: Publish
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: Setup git user
+        run: |
+          git config --global user.name "Netflix OSS Maintainers"
+          git config --global user.email "netflixoss@netflix.com"
+      - name: Set up JDK
+        uses: actions/setup-java@v5
+        with:
+          java-version: 8
+          distribution: 'zulu'
+      - uses: actions/cache@v5
+        id: gradle-cache
+        with:
+          path: |
+            ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
+      - uses: actions/cache@v5
+        id: gradle-wrapper-cache
+        with:
+          path: |
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradlewrapper-${{ hashFiles('gradle/wrapper/*') }}
+      - name: Build
+        run: ./gradlew build snapshot
+        env:
+          NETFLIX_OSS_SIGNING_KEY: ${{ secrets.ORG_SIGNING_KEY }}
+          NETFLIX_OSS_SIGNING_PASSWORD: ${{ secrets.ORG_SIGNING_PASSWORD }}
+          NETFLIX_OSS_REPO_USERNAME: ${{ secrets.ORG_NETFLIXOSS_USERNAME }}
+          NETFLIX_OSS_REPO_PASSWORD: ${{ secrets.ORG_NETFLIXOSS_PASSWORD }}

.gitignore

@@ -48,3 +48,5 @@ atlassian-ide-plugin.xml
 .settings
 .metadata
 
+# publishing secrets
+secrets/signing-key

README.md

@@ -4,12 +4,12 @@ Java Library that implements and integrates concepts from TCP congestion control
 
 # Background
 
-When thinking of service availability operators traditionally think in terms of RPS (requests per second). Stress tests are normally performed to determine the RPS at which point the service tips over. RPS limits are then set somewhere below this tipping point (say 75% of this value) and enforced via a token bucket. However, in large distributed systems that auto-scale this value quickly goes out of date and the service falls over by becoming non-responsive as it is unable to gracefully shed excess load. Instead of thinking in terms of RPS, we should be thinking in terms of concurrent request where we apply queuing theory to determine the number of concurrent requests a service can handle before a queue starts to build up, latencies increase and the service eventually exhausts a hard limit such as CPU, memory, disk or network. This relationship is covered very nicely with Little's Law where `Limit = Average RPS * Average Latency`.
+When thinking of service availability operators traditionally think in terms of RPS (requests per second). Stress tests are normally performed to determine the RPS at which point the service tips over. RPS limits are then set somewhere below this tipping point (say 75% of this value) and enforced via a token bucket. However, in large distributed systems that auto-scale this value quickly goes out of date and the service falls over by becoming non-responsive as it is unable to gracefully shed excess load. Instead of thinking in terms of RPS, we should be thinking in terms of concurrent requests where we apply queuing theory to determine the number of concurrent requests a service can handle before a queue starts to build up, latencies increase and the service eventually exhausts a hard limit such as CPU, memory, disk or network. This relationship is covered very nicely with Little's Law where `Limit = Average RPS * Average Latency`.
 
 Concurrency limits are very easy to enforce but difficult to determine as they would require operators to fully understand the hardware services run on and coordinate how they scale. Instead we'd prefer to measure or estimate the concurrency limits at each point in the network.  As systems scale and hit limits each node will adjust and enforce its local view of the limit. To estimate the limit we borrow from common TCP congestion control algorithms by equating a system's concurrency limit to a TCP congestion window. 
 
 Before applying the algorithm we need to set some ground rules. 
-* We accept that every system has an inherent concurrency limit that is determined by a hard resources, such as number of CPU cores. 
+* We accept that every system has an inherent concurrency limit that is determined by a hard resource, such as number of CPU cores. 
 * We accept that this limit can change as a system auto-scales.  
 * For large and complex distributed systems it's impossible to know all the hard resources.
 * We can use latency measurements to determine when queuing happens.
@@ -27,7 +27,7 @@ At the end of each sampling window the limit is increased by 1 if the queue is l
 
 ## Gradient2
 
-This algorithm attempts to address bias and drift when using minimum latency measurements. To do this the algorithm tracks uses the measure of divergence between two exponential averages over a long and short time time window. Using averages the algorithm can smooth out the impact of outliers for bursty traffic. Divergence duration is used as a proxy to identify a queueing trend at which point the algorithm aggresively reduces the limit.
+This algorithm attempts to address bias and drift when using minimum latency measurements. To do this the algorithm tracks the measure of divergence between two exponential averages over a long and short time window. Using averages the algorithm can smooth out the impact of outliers for bursty traffic. Divergence duration is used as a proxy to identify a queueing trend at which point the algorithm aggressively reduces the limit.
 
 # Enforcement Strategies
 
@@ -55,7 +55,7 @@ In this example a GRPC server is configured with a single adaptive limiter that
 // Create and configure a server builder
 ServerBuilder builder = ...;
 
-builder.addService(ServerInterceptor.intercept(service,
+builder.addService(ServerInterceptors.intercept(service,
     ConcurrencyLimitServerInterceptor.newBuilder(
         new GrpcServerLimiterBuilder()
             .partitionByHeader(GROUP_HEADER)

build.gradle

@@ -1,25 +1,46 @@
+import org.gradle.api.tasks.testing.Test
+
 buildscript {
     repositories {
-        jcenter()
+        mavenCentral()
+        maven {
+            url = 'https://plugins.gradle.org/m2'
+        }
     }
     dependencies {
         classpath 'org.junit.platform:junit-platform-gradle-plugin:1.0.2'
     }
 }
 
 plugins {
-    id 'nebula.netflixoss' version '6.1.0'
+    id 'nebula.netflixoss' version '11.6.0'
 }
 
 // Establish version and status
 ext.githubProjectName = rootProject.name 
 
 subprojects {
     apply plugin: 'nebula.netflixoss'
+    apply plugin: 'java-library'
     group = "com.netflix.${githubProjectName}" 
 
     repositories {
-        jcenter()
+        mavenCentral()
         maven { url 'https://jitpack.io' }
     }
+
+
+    ext {
+        grpcVersion = "1.9.0"
+        jUnitVersion = "5.+"
+        jUnitLegacyVersion = "4.+"
+        mockitoVersion = "4.+"
+        slf4jVersion = "1.7.+"
+        spectatorVersion = "1.+"
+        springVersion = "5.+"
+    }
+
+    tasks.withType(Test) {
+        useJUnitPlatform()
+    }
 }

concurrency-limits-core/build.gradle

@@ -5,10 +5,10 @@ plugins {
 sourceCompatibility = JavaVersion.VERSION_1_8
 
 dependencies {
-    compile "org.slf4j:slf4j-api:1.7.+"
-
-    testCompile 'junit:junit-dep:4.10'
-    testCompile "org.slf4j:slf4j-log4j12:1.7.+"
+    implementation "org.slf4j:slf4j-api:${slf4jVersion}"
 
-    testCompile 'com.github.kevinmost:junit-retry-rule:cbdd972d7c'
+    testCompileOnly "junit:junit:${jUnitLegacyVersion}"
+    testImplementation "org.slf4j:slf4j-log4j12:${slf4jVersion}"
+    testRuntimeOnly "org.junit.vintage:junit-vintage-engine:${jUnitVersion}"
+    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${jUnitVersion}"
 }

concurrency-limits-core/dependencies.lock

@@ -0,0 +1,37 @@
+{
+    "compileClasspath": {
+        "org.slf4j:slf4j-api": {
+            "locked": "1.7.36"
+        }
+    },
+    "runtimeClasspath": {
+        "org.slf4j:slf4j-api": {
+            "locked": "1.7.36"
+        }
+    },
+    "testCompileClasspath": {
+        "junit:junit": {
+            "locked": "4.13.2"
+        },
+        "org.slf4j:slf4j-api": {
+            "locked": "1.7.36"
+        },
+        "org.slf4j:slf4j-log4j12": {
+            "locked": "1.7.36"
+        }
+    },
+    "testRuntimeClasspath": {
+        "org.junit.jupiter:junit-jupiter-engine": {
+            "locked": "5.10.2"
+        },
+        "org.junit.vintage:junit-vintage-engine": {
+            "locked": "5.10.2"
+        },
+        "org.slf4j:slf4j-api": {
+            "locked": "1.7.36"
+        },
+        "org.slf4j:slf4j-log4j12": {
+            "locked": "1.7.36"
+        }
+    }
+}

concurrency-limits-core/src/main/java/com/netflix/concurrency/limits/Limit.java

@@ -35,8 +35,8 @@ public interface Limit {
 
     /**
      * Update the limiter with a sample
-     * @param startTime
-     * @param rtt
+     * @param startTime start time in nanoseconds
+     * @param rtt round trip time in nanoseconds
      * @param inflight
      * @param didDrop
      */

concurrency-limits-core/src/main/java/com/netflix/concurrency/limits/MetricRegistry.java

@@ -27,6 +27,14 @@ public interface MetricRegistry {
      */
     interface SampleListener {
         void addSample(Number value);
+
+        default void addLongSample(long value) {
+            addSample(value);
+        }
+
+        default void addDoubleSample(double value) {
+            addSample(value);
+        }
     }
 
     interface Counter {
@@ -59,7 +67,7 @@ default SampleListener distribution(String id, String... tagNameValuePairs) {
      */
     @Deprecated
     default void registerGauge(String id, Supplier<Number> supplier, String... tagNameValuePairs) {
-        throw new UnsupportedOperationException("registerDistribution is deprecated");
+        throw new UnsupportedOperationException("registerGauge is deprecated");
     }
 
     /**