cdk-github-microvm-runners 0.1.9__tar.gz → 0.1.10__tar.gz

{cdk_github_microvm_runners-0.1.9/src/cdk_github_microvm_runners.egg-info → cdk_github_microvm_runners-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cdk-github-microvm-runners
-Version: 0.1.9
+Version: 0.1.10
 Summary: CDK construct for running GitHub Actions jobs on AWS Lambda MicroVMs, with one ephemeral runner per job.
 Home-page: https://runnerset.dev
 Author: Court Schuett

{cdk_github_microvm_runners-0.1.9 → cdk_github_microvm_runners-0.1.10}/setup.py

@@ -5,7 +5,7 @@ kwargs = json.loads(
     """
 {
     "name": "cdk-github-microvm-runners",
-    "version": "0.1.9",
+    "version": "0.1.10",
     "description": "CDK construct for running GitHub Actions jobs on AWS Lambda MicroVMs, with one ephemeral runner per job.",
     "license": "Apache-2.0",
     "url": "https://runnerset.dev",
@@ -26,7 +26,7 @@ kwargs = json.loads(
     ],
     "package_data": {
         "cdk_github_microvm_runners._jsii": [
-            "cdk-github-microvm-runners@0.1.9.jsii.tgz"
+            "cdk-github-microvm-runners@0.1.10.jsii.tgz"
         ],
         "cdk_github_microvm_runners": [
             "py.typed"

{cdk_github_microvm_runners-0.1.9 → cdk_github_microvm_runners-0.1.10}/src/cdk_github_microvm_runners/__init__.py

@@ -860,7 +860,7 @@ class GithubMicrovmRunners(
         :param network: How launched MicroVMs and image builds reach the network. Default: RunnerNetwork.internetEgress()
         :param permissions_boundary: Permissions boundary applied to every IAM role this construct creates: the handler execution roles, the per-class image build roles, and the network-connector operator role. It is applied once at construct scope, so roles created later also carry it — the warm-pool handler's role, and the build role of any runner class registered after construction. Default: undefined (no boundary)
         :param point_in_time_recovery: Turn on DynamoDB point-in-time recovery for the runner table. Default: false
-        :param recover_stuck_launches: Re-launch jobs that are still waiting for a runner they never got. This is the floor under an event-driven plane, and it is on by default. GitHub announces a job once. If the launch that announcement triggered doesn't end with the job being served, nothing else ever asks again, and the job waits for as long as the workflow allows with no error anywhere — the plane looks healthy because by its own bookkeeping it did its work. Each janitor sweep closes that hole from two directions: it re-drives dead-lettered launch messages back onto the job queue, and it re-launches claims whose VM is gone while the job is still queued. Both check with GitHub first, so a job that has since completed or been cancelled is discarded rather than booting a VM for work nobody is waiting on. Turn it off only if you want a job that slips through to stay stuck. The cost of leaving it on is one extra GitHub read per sweep per candidate, bounded per sweep so it cannot exhaust the installation's rate limit. The janitor counts recoveries under the ``stuckLaunchesRecovered`` and ``stuckClaimsRelaunched`` metrics, which report when ``emitMetrics`` is on. A count that stays high means launches are failing for some ongoing reason and the recovery is masking it — alarm on it rather than ignoring it. Default: true
+        :param recover_stuck_launches: Re-launch jobs that are still waiting for a runner they never got. This is the floor under an event-driven plane, and it is on by default. GitHub announces a job once. If the launch that announcement triggered doesn't end with the job being served, nothing else ever asks again, and the job waits for as long as the workflow allows with no error anywhere — the plane looks healthy because by its own bookkeeping it did its work. Each janitor sweep closes that hole from three directions: it re-drives dead-lettered launch messages back onto the job queue, it re-launches claims whose VM is gone while the job is still queued, and it re-launches a job the instant its runner is reaped as ``unregistered`` (a VM that launched but never registered with GitHub). All three check with GitHub first, so a job that has since completed or been cancelled is discarded rather than booting a VM for work nobody is waiting on. The two relaunch paths (the committed-claim reconciliation and the ``unregistered`` reap) share ONE per-job attempt counter, threaded through the launch message onto the fresh claim, so a job that repeatedly fails to register is relaunched only a bounded number of times in total; at the bound its claim is released (deleted, so nothing resurrects it) and the exhaustion is raised via a metric and an error log rather than looping. The job then stays queued for the operator to re-run once the cause is fixed. Turn it off only if you want a job that slips through to stay stuck. The cost of leaving it on is one extra GitHub read per sweep per candidate, bounded per sweep so it cannot exhaust the installation's rate limit. The janitor counts recoveries under the ``stuckLaunchesRecovered``, ``stuckClaimsRelaunched``, and ``unregisteredRelaunched`` metrics, and jobs it released at the shared relaunch bound under ``unregisteredRelaunchExhausted`` (emitted from whichever recovery path hit the bound) — all report when ``emitMetrics`` is on. A count that stays high means launches are failing for some ongoing reason and the recovery is masking it — alarm on it rather than ignoring it. Default: true
         :param removal_policy: Removal policy for this runner set's stateful resources: the runner table and any log group the construct creates. The table holds correlation data for VMs that are currently running, all of which the janitor can rebuild from the MicroVM and GitHub APIs. Default: RemovalPolicy.DESTROY
         :param vm_execution_role: An AWS identity for this runner set's runner VMs. By default the VMs carry no AWS identity at all: the runner agent talks outbound to GitHub, the just-in-time registration is pushed to the VM over a platform-authenticated channel, and a job that needs AWS assumes its own role through GitHub OIDC. With a role attached, the MicroVM's instance metadata service serves that role's credentials to arbitrary job code, so every job running on this runner set can do whatever the role can do. ``consoleLogs`` requires a role, because the platform writes a VM's console output using it. Default: undefined (the VMs carry no AWS identity)
         :param warm_pool_interval: How often the warm-pool sweep refills pre-booted VMs. It applies only to runner classes that set ``RunnerClassProps.warmPoolSize``, and the warm-pool handler and its schedule are only created once such a class is registered. A runner set with no warm class never runs this sweep, and never reads this value. Default: Duration.minutes(2)
@@ -1641,6 +1641,24 @@ class GithubMicrovmRunnersMetrics(
         '''Janitor sweep count: runner table rows deleted, either because the VM they name is confirmed gone or because a real row superseded an orphaned one.'''
         return typing.cast("_aws_cdk_aws_cloudwatch_ceddda9d.Metric", jsii.invoke(self, "tableRowsCleaned", []))
 
+    @jsii.member(jsii_name="unregisteredRelaunched")
+    def unregistered_relaunched(self) -> "_aws_cdk_aws_cloudwatch_ceddda9d.Metric":
+        '''Janitor sweep count: still-queued jobs re-launched the moment their runner was reaped as ``unregistered`` (a VM that launched but never registered with GitHub).
+
+        This is 0 unless ``recoverStuckLaunches`` is on. A value that stays high means VMs are routinely failing to register — alarm on it.
+        '''
+        return typing.cast("_aws_cdk_aws_cloudwatch_ceddda9d.Metric", jsii.invoke(self, "unregisteredRelaunched", []))
+
+    @jsii.member(jsii_name="unregisteredRelaunchExhausted")
+    def unregistered_relaunch_exhausted(
+        self,
+    ) -> "_aws_cdk_aws_cloudwatch_ceddda9d.Metric":
+        '''Janitor sweep count: jobs RELEASED (claim deleted) at the shared relaunch bound because they had already been re-launched the maximum number of times across BOTH recovery paths (the ``unregistered`` reap and the committed-claim reconciliation) and still never registered.
+
+        The released job stays ``queued`` for the operator to re-run once the cause is fixed. Any non-zero value is a job that stranded despite recovery — alarm on it. This is 0 unless ``recoverStuckLaunches`` is on.
+        '''
+        return typing.cast("_aws_cdk_aws_cloudwatch_ceddda9d.Metric", jsii.invoke(self, "unregisteredRelaunchExhausted", []))
+
     @jsii.member(jsii_name="warmHit")
     def warm_hit(
         self,
@@ -1770,7 +1788,7 @@ class GithubMicrovmRunnersProps:
         :param network: How launched MicroVMs and image builds reach the network. Default: RunnerNetwork.internetEgress()
         :param permissions_boundary: Permissions boundary applied to every IAM role this construct creates: the handler execution roles, the per-class image build roles, and the network-connector operator role. It is applied once at construct scope, so roles created later also carry it — the warm-pool handler's role, and the build role of any runner class registered after construction. Default: undefined (no boundary)
         :param point_in_time_recovery: Turn on DynamoDB point-in-time recovery for the runner table. Default: false
-        :param recover_stuck_launches: Re-launch jobs that are still waiting for a runner they never got. This is the floor under an event-driven plane, and it is on by default. GitHub announces a job once. If the launch that announcement triggered doesn't end with the job being served, nothing else ever asks again, and the job waits for as long as the workflow allows with no error anywhere — the plane looks healthy because by its own bookkeeping it did its work. Each janitor sweep closes that hole from two directions: it re-drives dead-lettered launch messages back onto the job queue, and it re-launches claims whose VM is gone while the job is still queued. Both check with GitHub first, so a job that has since completed or been cancelled is discarded rather than booting a VM for work nobody is waiting on. Turn it off only if you want a job that slips through to stay stuck. The cost of leaving it on is one extra GitHub read per sweep per candidate, bounded per sweep so it cannot exhaust the installation's rate limit. The janitor counts recoveries under the ``stuckLaunchesRecovered`` and ``stuckClaimsRelaunched`` metrics, which report when ``emitMetrics`` is on. A count that stays high means launches are failing for some ongoing reason and the recovery is masking it — alarm on it rather than ignoring it. Default: true
+        :param recover_stuck_launches: Re-launch jobs that are still waiting for a runner they never got. This is the floor under an event-driven plane, and it is on by default. GitHub announces a job once. If the launch that announcement triggered doesn't end with the job being served, nothing else ever asks again, and the job waits for as long as the workflow allows with no error anywhere — the plane looks healthy because by its own bookkeeping it did its work. Each janitor sweep closes that hole from three directions: it re-drives dead-lettered launch messages back onto the job queue, it re-launches claims whose VM is gone while the job is still queued, and it re-launches a job the instant its runner is reaped as ``unregistered`` (a VM that launched but never registered with GitHub). All three check with GitHub first, so a job that has since completed or been cancelled is discarded rather than booting a VM for work nobody is waiting on. The two relaunch paths (the committed-claim reconciliation and the ``unregistered`` reap) share ONE per-job attempt counter, threaded through the launch message onto the fresh claim, so a job that repeatedly fails to register is relaunched only a bounded number of times in total; at the bound its claim is released (deleted, so nothing resurrects it) and the exhaustion is raised via a metric and an error log rather than looping. The job then stays queued for the operator to re-run once the cause is fixed. Turn it off only if you want a job that slips through to stay stuck. The cost of leaving it on is one extra GitHub read per sweep per candidate, bounded per sweep so it cannot exhaust the installation's rate limit. The janitor counts recoveries under the ``stuckLaunchesRecovered``, ``stuckClaimsRelaunched``, and ``unregisteredRelaunched`` metrics, and jobs it released at the shared relaunch bound under ``unregisteredRelaunchExhausted`` (emitted from whichever recovery path hit the bound) — all report when ``emitMetrics`` is on. A count that stays high means launches are failing for some ongoing reason and the recovery is masking it — alarm on it rather than ignoring it. Default: true
         :param removal_policy: Removal policy for this runner set's stateful resources: the runner table and any log group the construct creates. The table holds correlation data for VMs that are currently running, all of which the janitor can rebuild from the MicroVM and GitHub APIs. Default: RemovalPolicy.DESTROY
         :param vm_execution_role: An AWS identity for this runner set's runner VMs. By default the VMs carry no AWS identity at all: the runner agent talks outbound to GitHub, the just-in-time registration is pushed to the VM over a platform-authenticated channel, and a job that needs AWS assumes its own role through GitHub OIDC. With a role attached, the MicroVM's instance metadata service serves that role's credentials to arbitrary job code, so every job running on this runner set can do whatever the role can do. ``consoleLogs`` requires a role, because the platform writes a VM's console output using it. Default: undefined (the VMs carry no AWS identity)
         :param warm_pool_interval: How often the warm-pool sweep refills pre-booted VMs. It applies only to runner classes that set ``RunnerClassProps.warmPoolSize``, and the warm-pool handler and its schedule are only created once such a class is registered. A runner set with no warm class never runs this sweep, and never reads this value. Default: Duration.minutes(2)
@@ -2103,20 +2121,32 @@ class GithubMicrovmRunnersProps:
         doesn't end with the job being served, nothing else ever asks again, and
         the job waits for as long as the workflow allows with no error anywhere —
         the plane looks healthy because by its own bookkeeping it did its work.
-        Each janitor sweep closes that hole from two directions: it re-drives
-        dead-lettered launch messages back onto the job queue, and it re-launches
-        claims whose VM is gone while the job is still queued. Both check with
-        GitHub first, so a job that has since completed or been cancelled is
-        discarded rather than booting a VM for work nobody is waiting on.
+        Each janitor sweep closes that hole from three directions: it re-drives
+        dead-lettered launch messages back onto the job queue, it re-launches
+        claims whose VM is gone while the job is still queued, and it re-launches a
+        job the instant its runner is reaped as ``unregistered`` (a VM that launched
+        but never registered with GitHub). All three check with GitHub first, so a
+        job that has since completed or been cancelled is discarded rather than
+        booting a VM for work nobody is waiting on. The two relaunch paths (the
+        committed-claim reconciliation and the ``unregistered`` reap) share ONE
+        per-job attempt counter, threaded through the launch message onto the fresh
+        claim, so a job that repeatedly fails to register is relaunched only a
+        bounded number of times in total; at the bound its claim is released
+        (deleted, so nothing resurrects it) and the exhaustion is raised via a
+        metric and an error log rather than looping. The job then stays queued for
+        the operator to re-run once the cause is fixed.
 
         Turn it off only if you want a job that slips through to stay stuck. The
         cost of leaving it on is one extra GitHub read per sweep per candidate,
         bounded per sweep so it cannot exhaust the installation's rate limit.
 
-        The janitor counts recoveries under the ``stuckLaunchesRecovered`` and
-        ``stuckClaimsRelaunched`` metrics, which report when ``emitMetrics`` is on. A
-        count that stays high means launches are failing for some ongoing reason
-        and the recovery is masking it — alarm on it rather than ignoring it.
+        The janitor counts recoveries under the ``stuckLaunchesRecovered``,
+        ``stuckClaimsRelaunched``, and ``unregisteredRelaunched`` metrics, and jobs it
+        released at the shared relaunch bound under ``unregisteredRelaunchExhausted``
+        (emitted from whichever recovery path hit the bound) — all report
+        when ``emitMetrics`` is on. A count that stays high means launches are
+        failing for some ongoing reason and the recovery is masking it — alarm on
+        it rather than ignoring it.
 
         :default: true
         '''

{cdk_github_microvm_runners-0.1.9 → cdk_github_microvm_runners-0.1.10}/src/cdk_github_microvm_runners/_jsii/__init__.py

@@ -19,9 +19,9 @@ import constructs._jsii
 
 __jsii_assembly__ = jsii.JSIIAssembly.load(
     "cdk-github-microvm-runners",
-    "0.1.9",
+    "0.1.10",
     __name__[0:-6],
-    "cdk-github-microvm-runners@0.1.9.jsii.tgz",
+    "cdk-github-microvm-runners@0.1.10.jsii.tgz",
 )
 
 __all__ = [

{cdk_github_microvm_runners-0.1.9 → cdk_github_microvm_runners-0.1.10}/src/cdk_github_microvm_runners/_jsii/bin/cdk-github-microvm-runners

@@ -9,9 +9,9 @@ if "JSII_RUNTIME_PACKAGE_CACHE" not in os.environ:
 
 __jsii_assembly__ = jsii.JSIIAssembly.load(
     "cdk-github-microvm-runners",
-    "0.1.9",
+    "0.1.10",
     "cdk_github_microvm_runners",
-    "cdk-github-microvm-runners@0.1.9.jsii.tgz",
+    "cdk-github-microvm-runners@0.1.10.jsii.tgz",
 )
 
 exit_code = __jsii_assembly__.invokeBinScript(

{cdk_github_microvm_runners-0.1.9 → cdk_github_microvm_runners-0.1.10/src/cdk_github_microvm_runners.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cdk-github-microvm-runners
-Version: 0.1.9
+Version: 0.1.10
 Summary: CDK construct for running GitHub Actions jobs on AWS Lambda MicroVMs, with one ephemeral runner per job.
 Home-page: https://runnerset.dev
 Author: Court Schuett

{cdk_github_microvm_runners-0.1.9 → cdk_github_microvm_runners-0.1.10}/src/cdk_github_microvm_runners.egg-info/SOURCES.txt

@@ -11,5 +11,5 @@ src/cdk_github_microvm_runners.egg-info/dependency_links.txt
 src/cdk_github_microvm_runners.egg-info/requires.txt
 src/cdk_github_microvm_runners.egg-info/top_level.txt
 src/cdk_github_microvm_runners/_jsii/__init__.py
-src/cdk_github_microvm_runners/_jsii/cdk-github-microvm-runners@0.1.9.jsii.tgz
+src/cdk_github_microvm_runners/_jsii/cdk-github-microvm-runners@0.1.10.jsii.tgz
 src/cdk_github_microvm_runners/_jsii/bin/cdk-github-microvm-runners