Add `ruff-format` to `treefmt` (to format Python files)
All I did here was: - Add `ruff-format` - Run `nix fmt` - Remove `black` stuff from `hydra-packet-importer/` Why? I'm going to add a helper script to https://github.com/NixOS/infra/pull/495#issuecomment-2443284452, and I'd like to write it in Python and have autoformatting.
Jeremy Fleischman committed
Oct 29, 2024 at 11:52 UTC
3440e39c5f2f10d41bc821d9a85f92398a0a2277
5 files changed
+140
-142
build/datadog/hydra.py
+5
-3
@@ -5,8 +5,10 @@ import subprocess
5
import requests
6
import json
7
8
+
9
class HydraCheck(AgentCheck):
10
def check(self, instance):
10
- r = requests.get('http://localhost:3000/status', headers={'Content-Type':'application/json'})
11
- self.gauge('hydra.active_buildsteps', len(json.loads(r.text)))
12
-
11
+ r = requests.get(
12
+ "http://localhost:3000/status", headers={"Content-Type": "application/json"}
13
+ )
14
+ self.gauge("hydra.active_buildsteps", len(json.loads(r.text)))
build/pluto/prometheus/exporters/channel-exporter.py
+24
-11
@@ -35,16 +35,19 @@ CHANNEL_REQUEST_FAILURES = Counter(
35
"Number of channel status requests which have failed",
36
)
37
38
+
39
@CHANNEL_REQUEST_TIME.time()
40
def measure_channel(name):
41
try:
42
with CHANNEL_REQUEST_FAILURES.count_exceptions():
42
- result = requests.get(f"https://nixos.org/channels/{name}/git-revision", timeout=10)
43
+ result = requests.get(
44
+ f"https://nixos.org/channels/{name}/git-revision", timeout=10
45
+ )
46
47
try:
48
return {
49
"timestamp": parse(result.headers["last-modified"]).timestamp(),
47
- "revision": result.text
50
+ "revision": result.text,
51
}
52
except KeyError as e:
53
print(f"Got KeyError after getting our result for {name}:")
@@ -66,19 +69,29 @@ if __name__ == "__main__":
69
revisions = {}
70
71
while True:
69
- for (channel, about) in channels.items():
72
+ for channel, about in channels.items():
73
measurement = measure_channel(channel)
74
if measurement is not None:
72
- revision = measurement['revision']
73
- status = about.get('status', '')
74
- variant = about.get('variant', '')
75
- current = int(status != 'unmaintained')
76
- CHANNEL_UPDATE_TIME.labels(channel=channel).set(measurement['timestamp'])
77
- CHANNEL_REVISION.labels(channel=channel, revision=revision, status=status, variant=variant, current=current).set(1)
75
+ revision = measurement["revision"]
76
+ status = about.get("status", "")
77
+ variant = about.get("variant", "")
78
+ current = int(status != "unmaintained")
79
+ CHANNEL_UPDATE_TIME.labels(channel=channel).set(
80
+ measurement["timestamp"]
81
+ )
82
+ CHANNEL_REVISION.labels(
83
+ channel=channel,
84
+ revision=revision,
85
+ status=status,
86
+ variant=variant,
87
+ current=current,
88
+ ).set(1)
89
CHANNEL_CURRENT.labels(channel=channel).set(current)
79
- print('updated {}'.format(channel))
90
+ print("updated {}".format(channel))
91
previous_revision = revisions.pop(channel, None)
92
revisions[channel] = revision
93
if previous_revision and previous_revision != revision:
83
- CHANNEL_REVISION.remove(channel, previous_revision, status, variant, current)
94
+ CHANNEL_REVISION.remove(
95
+ channel, previous_revision, status, variant, current
96
+ )
97
time.sleep(55)
build/pluto/prometheus/exporters/hydra-queue-runner-reexporter.py
+109
-123
@@ -8,10 +8,12 @@ from prometheus_client import CollectorRegistry, generate_latest, start_http_ser
8
from pprint import pprint
9
import time
10
11
+
12
def debug_remaining_state(edict):
13
# pprint(edict.remaining_state())
14
pass
15
16
+
17
class EvaporatingDict:
18
def __init__(self, state):
19
self._state = state
@@ -57,6 +59,7 @@ class EvaporatingDict:
59
for key in keys:
60
yield (key, self.destructive_read(key))
61
62
+
63
class HydraScrapeImporter:
64
def __init__(self, status):
65
self._status = EvaporatingDict(status)
@@ -67,115 +70,109 @@ class HydraScrapeImporter:
70
yield self.trivial_gauge(
71
"up",
72
"Is hydra running",
70
- 1 if self.destructive_read("status") == "up" else 0
73
+ 1 if self.destructive_read("status") == "up" else 0,
74
)
75
yield self.trivial_counter(
73
- "time",
74
- "Hydra's current time",
75
- self.destructive_read("time")
76
+ "time", "Hydra's current time", self.destructive_read("time")
77
)
78
yield self.trivial_counter(
78
- "uptime",
79
- "Hydra's uptime",
80
- self.destructive_read("uptime")
79
+ "uptime", "Hydra's uptime", self.destructive_read("uptime")
80
)
81
self.unused_metric("pid")
82
yield self.trivial_gauge(
83
"builds_queued",
84
"Current build queue size",
86
- self.destructive_read("nrQueuedBuilds")
85
+ self.destructive_read("nrQueuedBuilds"),
86
)
87
yield self.trivial_gauge(
88
"steps_queued",
89
"Current number of steps for the build queue",
91
- self.destructive_read("nrUnfinishedSteps")
90
+ self.destructive_read("nrUnfinishedSteps"),
91
)
92
yield self.trivial_gauge(
93
"steps_runnable",
94
"Current number of steps which can run immediately",
96
- self.destructive_read("nrRunnableSteps")
95
+ self.destructive_read("nrRunnableSteps"),
96
)
97
yield self.trivial_gauge(
98
"steps_active",
99
"Current number of steps which are currently active",
101
- self.destructive_read("nrActiveSteps")
100
+ self.destructive_read("nrActiveSteps"),
101
)
102
yield self.trivial_gauge(
103
"steps_building",
104
"Current number of steps which are currently building",
106
- self.destructive_read("nrStepsBuilding")
105
+ self.destructive_read("nrStepsBuilding"),
106
)
107
yield self.trivial_gauge(
108
"steps_copying_to",
109
"Current number of steps which are having build inputs copied to a builder",
111
- self.destructive_read("nrStepsCopyingTo")
110
+ self.destructive_read("nrStepsCopyingTo"),
111
)
112
yield self.trivial_gauge(
113
"steps_copying_from",
114
"Current number of steps which are having build results copied from a builder",
116
- self.destructive_read("nrStepsCopyingFrom")
115
+ self.destructive_read("nrStepsCopyingFrom"),
116
)
117
yield self.trivial_gauge(
118
"steps_waiting",
119
"Current number of steps which are waiting",
121
- self.destructive_read("nrStepsWaiting")
122
- )
120
+ self.destructive_read("nrStepsWaiting"),
121
+ )
122
yield self.trivial_counter(
123
"build_inputs_sent_bytes",
124
"Total count of bytes sent due to build inputs",
126
- self.destructive_read("bytesSent")
125
+ self.destructive_read("bytesSent"),
126
)
127
yield self.trivial_counter(
128
"build_outputs_received_bytes",
129
"Total count of bytes received from build outputs",
131
- self.destructive_read("bytesReceived")
130
+ self.destructive_read("bytesReceived"),
131
)
132
yield self.trivial_counter(
133
"builds_read",
134
"Total count of builds whose outputs have been read",
136
- self.destructive_read("nrBuildsRead")
135
+ self.destructive_read("nrBuildsRead"),
136
)
137
yield self.trivial_counter(
138
"builds_read_seconds",
139
"Total number of seconds spent reading build outputs",
141
- self.destructive_read("buildReadTimeMs") / 1000
140
+ self.destructive_read("buildReadTimeMs") / 1000,
141
)
143
- self.unused_metric("buildReadTimeAvgMs") # implementable in prometheus queries
142
+ self.unused_metric("buildReadTimeAvgMs") # implementable in prometheus queries
143
144
yield self.trivial_counter(
145
"builds_done",
146
"Total count of builds performed",
148
- self.destructive_read("nrBuildsDone")
147
+ self.destructive_read("nrBuildsDone"),
148
)
149
yield self.trivial_counter(
150
"steps_started",
151
"Total count of steps started",
153
- self.destructive_read("nrStepsStarted")
152
+ self.destructive_read("nrStepsStarted"),
153
)
154
yield self.trivial_counter(
155
"steps_done",
156
"Total count of steps completed",
158
- self.destructive_read("nrStepsDone")
157
+ self.destructive_read("nrStepsDone"),
158
)
159
yield self.trivial_counter(
161
- "retries",
162
- "Total count of retries",
163
- self.destructive_read("nrRetries")
160
+ "retries", "Total count of retries", self.destructive_read("nrRetries")
161
)
162
yield self.trivial_counter(
163
"max_retries",
164
"Maximum count of retries for any single job",
168
- self.destructive_read("maxNrRetries")
165
+ self.destructive_read("maxNrRetries"),
166
)
167
yield self.trivial_counter(
168
"step_time",
169
"Total time spent executing steps",
173
- self.destructive_read_default("totalStepTime", 0)
170
+ self.destructive_read_default("totalStepTime", 0),
171
)
172
yield self.trivial_counter(
173
"step_build_time",
174
"Total time spent executing builds steps (???)",
178
- self.destructive_read_default("totalStepBuildTime", 0)
175
+ self.destructive_read_default("totalStepBuildTime", 0),
176
)
177
self.unused_metric("avgStepTime")
178
self.unused_metric("avgStepBuildTime")
@@ -183,60 +180,60 @@ class HydraScrapeImporter:
180
yield self.trivial_counter(
181
"queue_wakeup",
182
"Count of the times the queue runner has been notified of queue changes",
186
- self.destructive_read("nrQueueWakeups")
183
+ self.destructive_read("nrQueueWakeups"),
184
)
185
yield self.trivial_counter(
186
"dispatcher_wakeup",
187
"Count of the times the queue runner work dispatcher woke up due to new runnable builds and completed builds.",
191
- self.destructive_read("nrDispatcherWakeups")
188
+ self.destructive_read("nrDispatcherWakeups"),
189
)
190
yield self.trivial_counter(
191
"dispatch_execution_seconds",
192
"Number of seconds the dispatcher has spent working",
196
- self.destructive_read("dispatchTimeMs") / 1000
193
+ self.destructive_read("dispatchTimeMs") / 1000,
194
)
195
self.unused_metric("dispatchTimeAvgMs")
196
197
yield self.trivial_gauge(
198
"db_connections",
199
"Number of connections to the database",
203
- self.destructive_read("nrDbConnections")
200
+ self.destructive_read("nrDbConnections"),
201
)
202
yield self.trivial_gauge(
203
"db_updates",
204
"Number of in-progress database updates",
208
- self.destructive_read("nrActiveDbUpdates")
205
+ self.destructive_read("nrActiveDbUpdates"),
206
)
207
yield self.trivial_counter(
208
"notifications_total",
209
"Total number of notifications sent",
213
- self.preserving_read_default("nrNotificationsDone", 0) +
214
- self.preserving_read_default("nrNotificationsFailed", 0)
210
+ self.preserving_read_default("nrNotificationsDone", 0)
211
+ + self.preserving_read_default("nrNotificationsFailed", 0),
212
)
213
yield self.trivial_counter(
214
"notifications_done",
215
"Number of notifications completed",
219
- self.destructive_read_default("nrNotificationsDone", 0)
216
+ self.destructive_read_default("nrNotificationsDone", 0),
217
)
218
yield self.trivial_counter(
219
"notifications_failed",
220
"Number of notifications failed",
224
- self.destructive_read_default("nrNotificationsFailed", 0)
221
+ self.destructive_read_default("nrNotificationsFailed", 0),
222
)
223
yield self.trivial_counter(
224
"notifications_in_progress",
225
"Number of notifications in_progress",
229
- self.destructive_read_default("nrNotificationsInProgress", 0)
226
+ self.destructive_read_default("nrNotificationsInProgress", 0),
227
)
228
yield self.trivial_counter(
229
"notifications_pending",
230
"Number of notifications pending",
234
- self.destructive_read_default("nrNotificationsPending", 0)
231
+ self.destructive_read_default("nrNotificationsPending", 0),
232
)
233
yield self.trivial_counter(
234
"notifications_seconds",
235
"Time spent delivering notifications",
239
- self.destructive_read_default("nrNotificationTimeMs", 0) / 1000
236
+ self.destructive_read_default("nrNotificationTimeMs", 0) / 1000,
237
)
238
self.unused_metric("nrNotificationTimeAvgMs")
239
@@ -262,67 +259,67 @@ class HydraScrapeImporter:
259
yield self.trivial_counter(
260
"store_nar_info_read",
261
"Number of NarInfo files read from the binary cache",
265
- store.destructive_read("narInfoRead")
262
+ store.destructive_read("narInfoRead"),
263
)
264
yield self.trivial_counter(
265
"store_nar_info_read_averted",
266
"Number of NarInfo files reads which were avoided",
270
- store.destructive_read("narInfoReadAverted")
267
+ store.destructive_read("narInfoReadAverted"),
268
)
269
yield self.trivial_counter(
270
"store_nar_info_missing",
271
"Number of NarInfo files read attempts which identified a missing narinfo file",
275
- store.destructive_read("narInfoMissing")
272
+ store.destructive_read("narInfoMissing"),
273
)
274
yield self.trivial_counter(
275
"store_nar_info_write",
276
"Number of NarInfo files written to the binary cache",
280
- store.destructive_read("narInfoWrite")
277
+ store.destructive_read("narInfoWrite"),
278
)
279
yield self.trivial_gauge(
280
"store_nar_info_cache_size",
281
"Size of the in-memory store path information cache",
285
- store.destructive_read("narInfoCacheSize")
282
+ store.destructive_read("narInfoCacheSize"),
283
)
284
yield self.trivial_counter(
285
"store_nar_read",
286
"Number of NAR files read from the binary cache",
290
- store.destructive_read("narRead")
287
+ store.destructive_read("narRead"),
288
)
289
yield self.trivial_counter(
290
"store_nar_read_bytes",
291
"Number of NAR file bytes read after decompression from the binary cache",
295
- store.destructive_read("narReadBytes")
292
+ store.destructive_read("narReadBytes"),
293
)
294
yield self.trivial_counter(
295
"store_nar_read_compressed_bytes",
296
"Number of NAR file bytes read before decompression from the binary cache",
300
- store.destructive_read("narReadCompressedBytes")
297
+ store.destructive_read("narReadCompressedBytes"),
298
)
299
yield self.trivial_counter(
300
"store_nar_write",
301
"Number of NAR files written to the binary cache",
305
- store.destructive_read("narWrite")
302
+ store.destructive_read("narWrite"),
303
)
304
yield self.trivial_counter(
305
"store_nar_write_averted",
306
"Number of NAR files writes skipped due to the NAR already being in the binary cache",
310
- store.destructive_read("narWriteAverted")
307
+ store.destructive_read("narWriteAverted"),
308
)
309
yield self.trivial_counter(
310
"store_nar_write_bytes",
311
"Number of NAR file bytes written after decompression to the binary cache",
315
- store.destructive_read("narWriteBytes")
312
+ store.destructive_read("narWriteBytes"),
313
)
314
yield self.trivial_counter(
315
"store_nar_write_compressed_bytes",
316
"Number of NAR file bytes written before decompression to the binary cache",
320
- store.destructive_read("narWriteCompressedBytes")
317
+ store.destructive_read("narWriteCompressedBytes"),
318
)
319
yield self.trivial_counter(
320
"store_nar_write_compression_seconds",
321
"Number of seconds spent compressing data when writing NARs to the binary cache",
325
- store.destructive_read("narWriteCompressionTimeMs") / 1000
322
+ store.destructive_read("narWriteCompressionTimeMs") / 1000,
323
)
324
store.unused_read("narCompressionSavings")
325
store.unused_read("narCompressionSpeed")
@@ -337,47 +334,41 @@ class HydraScrapeImporter:
334
# Not in the above try to avoid the try catching mistakes
335
# in the following code
336
yield self.trivial_counter(
340
- "store_s3_put",
341
- "Number of PUTs to S3",
342
- s3.destructive_read("put")
337
+ "store_s3_put", "Number of PUTs to S3", s3.destructive_read("put")
338
)
339
yield self.trivial_counter(
340
"store_s3_put_bytes",
341
"Number of bytes written to S3",
347
- s3.destructive_read("putBytes")
342
+ s3.destructive_read("putBytes"),
343
)
344
yield self.trivial_counter(
345
"store_s3_put_seconds",
346
"Number of seconds spent writing to S3",
352
- s3.destructive_read("putTimeMs") / 1000
347
+ s3.destructive_read("putTimeMs") / 1000,
348
)
349
s3.unused_read("putSpeed")
350
yield self.trivial_counter(
356
- "store_s3_get",
357
- "Number of GETs to S3",
358
- s3.destructive_read("get")
351
+ "store_s3_get", "Number of GETs to S3", s3.destructive_read("get")
352
)
353
yield self.trivial_counter(
354
"store_s3_get_bytes",
355
"Number of bytes read from S3",
363
- s3.destructive_read("getBytes")
356
+ s3.destructive_read("getBytes"),
357
)
358
yield self.trivial_counter(
359
"store_s3_get_seconds",
360
"Number of seconds spent reading from S3",
368
- s3.destructive_read("getTimeMs") / 1000
361
+ s3.destructive_read("getTimeMs") / 1000,
362
)
363
s3.unused_read("getSpeed")
364
365
yield self.trivial_counter(
373
- "store_s3_head",
374
- "Number of HEADs to S3",
375
- s3.destructive_read("head")
366
+ "store_s3_head", "Number of HEADs to S3", s3.destructive_read("head")
367
)
368
yield self.trivial_counter(
369
"store_s3_cost_approximate_dollars",
370
"Estimated cost of the S3 bucket activity",
380
- s3.destructive_read("costDollarApprox")
371
+ s3.destructive_read("costDollarApprox"),
372
)
373
debug_remaining_state(s3)
374
debug_remaining_state(store)
@@ -410,48 +401,55 @@ class HydraScrapeImporter:
401
def uncollected_status(self):
402
return self._status.remaining_state()
403
404
+
405
def blackhole(*args, **kwargs):
406
return None
407
408
+
409
class MachineScrapeImporter:
410
def __init__(self):
418
- labels = [ "host" ]
411
+ labels = ["host"]
412
self.consective_failures = GaugeMetricFamily(
413
"hydra_machine_consecutive_failures",
414
"Number of consecutive failed builds",
422
- labels=labels)
415
+ labels=labels,
416
+ )
417
self.current_jobs = GaugeMetricFamily(
424
- "hydra_machine_current_jobs",
425
- "Number of current jobs",
426
- labels=labels)
418
+ "hydra_machine_current_jobs", "Number of current jobs", labels=labels
419
+ )
420
self.idle_since = GaugeMetricFamily(
421
"hydra_machine_idle_since",
422
"When the current idle period started",
430
- labels=labels)
423
+ labels=labels,
424
+ )
425
self.disabled_until = GaugeMetricFamily(
426
"hydra_machine_disabled_until",
427
"When the machine will be used again",
434
- labels=labels)
428
+ labels=labels,
429
+ )
430
self.enabled = GaugeMetricFamily(
431
"hydra_machine_enabled",
432
"If the machine is enabled (1) or not (0)",
438
- labels=labels)
433
+ labels=labels,
434
+ )
435
self.last_failure = CounterMetricFamily(
440
- "hydra_machine_last_failure",
441
- "timestamp of the last failure",
442
- labels=labels)
436
+ "hydra_machine_last_failure", "timestamp of the last failure", labels=labels
437
+ )
438
self.number_steps_done = CounterMetricFamily(
439
"hydra_machine_steps_done_total",
440
"Total count of the steps completed",
446
- labels=labels)
441
+ labels=labels,
442
+ )
443
self.total_step_build_time = CounterMetricFamily(
444
"hydra_machine_step_build_time_total",
445
"Number of seconds spent building steps",
450
- labels=labels)
446
+ labels=labels,
447
+ )
448
self.total_step_time = CounterMetricFamily(
449
"hydra_machine_step_time_total",
450
"Number of seconds spent on steps",
454
- labels=labels)
451
+ labels=labels,
452
+ )
453
454
def load_machine(self, name, report):
455
report.unused_read("mandatoryFeatures")
@@ -461,45 +459,27 @@ class MachineScrapeImporter:
459
report.unused_read("avgStepTime")
460
labels = [name]
461
self.consective_failures.add_metric(
464
- labels,
465
- report.destructive_read("consecutiveFailures")
466
- )
467
- self.current_jobs.add_metric(
468
- labels,
469
- report.destructive_read("currentJobs")
462
+ labels, report.destructive_read("consecutiveFailures")
463
)
464
+ self.current_jobs.add_metric(labels, report.destructive_read("currentJobs"))
465
try:
472
- self.idle_since.add_metric(
473
- labels,
474
- report.destructive_read("idleSince")
475
- )
466
+ self.idle_since.add_metric(labels, report.destructive_read("idleSince"))
467
except KeyError:
468
pass
478
- self.disabled_until.add_metric(
479
- labels,
480
- report.destructive_read("disabledUntil")
481
- )
482
- self.enabled.add_metric(
483
- labels,
484
- 1 if report.destructive_read("enabled") else 0
485
- )
486
- self.last_failure.add_metric(
487
- labels,
488
- report.destructive_read("lastFailure")
489
- )
469
+ self.disabled_until.add_metric(labels, report.destructive_read("disabledUntil"))
470
+ self.enabled.add_metric(labels, 1 if report.destructive_read("enabled") else 0)
471
+ self.last_failure.add_metric(labels, report.destructive_read("lastFailure"))
472
self.number_steps_done.add_metric(
491
- labels,
492
- report.destructive_read("nrStepsDone")
473
+ labels, report.destructive_read("nrStepsDone")
474
)
475
self.total_step_build_time.add_metric(
495
- labels,
496
- report.destructive_read_default("totalStepBuildTime", default=0)
476
+ labels, report.destructive_read_default("totalStepBuildTime", default=0)
477
)
478
self.total_step_time.add_metric(
499
- labels,
500
- report.destructive_read_default("totalStepTime", default=0)
479
+ labels, report.destructive_read_default("totalStepTime", default=0)
480
)
481
debug_remaining_state(report)
482
+
483
def metrics(self):
484
yield self.consective_failures
485
yield self.current_jobs
@@ -517,11 +497,13 @@ class JobsetScrapeImporter:
497
self.seconds = CounterMetricFamily(
498
"hydra_jobset_seconds_total",
499
"Total number of seconds the jobset has been building",
520
- labels=["name"])
500
+ labels=["name"],
501
+ )
502
self.shares_used = CounterMetricFamily(
503
"hydra_jobset_shares_used_total",
504
"Total shares the jobset has consumed",
524
- labels=["name"])
505
+ labels=["name"],
506
+ )
507
508
def load_jobset(self, name, report):
509
self.seconds.add_metric([name], report.destructive_read("seconds"))
@@ -538,20 +520,23 @@ class MachineTypeScrapeImporter:
520
self.runnable = GaugeMetricFamily(
521
"hydra_machine_type_runnable",
522
"Number of currently runnable builds",
541
- labels=["machineType"])
523
+ labels=["machineType"],
524
+ )
525
self.running = GaugeMetricFamily(
526
"hydra_machine_type_running",
527
"Number of currently running builds",
545
- labels=["machineType"])
528
+ labels=["machineType"],
529
+ )
530
self.wait_time = CounterMetricFamily(
531
"hydra_machine_type_wait_time_total",
532
"Number of seconds spent waiting",
549
- labels=["machineType"])
533
+ labels=["machineType"],
534
+ )
535
self.last_active = CounterMetricFamily(
536
"hydra_machine_type_last_active_total",
537
"Last time this machine type was active",
553
- labels=["machineType"])
554
-
538
+ labels=["machineType"],
539
+ )
540
541
def load_machine_type(self, name, report):
542
self.runnable.add_metric([name], report.destructive_read("runnable"))
@@ -573,6 +558,7 @@ class MachineTypeScrapeImporter:
558
yield self.wait_time
559
yield self.last_active
560
561
+
562
class ScrapeCollector:
563
def __init__(self):
564
pass
@@ -580,6 +566,7 @@ class ScrapeCollector:
566
def collect(self):
567
return HydraScrapeImporter(scrape()).collect()
568
569
+
570
def scrape(cached=None):
571
if cached:
572
with open(cached) as f:
@@ -587,17 +574,16 @@ def scrape(cached=None):
574
else:
575
print("Scraping")
576
return requests.get(
590
- 'https://hydra.nixos.org/queue-runner-status',
591
- headers={
592
- "Content-Type": "application/json"
593
- }
577
+ "https://hydra.nixos.org/queue-runner-status",
578
+ headers={"Content-Type": "application/json"},
579
).json()
580
581
+
582
registry = CollectorRegistry()
583
584
registry.register(ScrapeCollector())
585
600
-if __name__ == '__main__':
586
+if __name__ == "__main__":
587
# Start up the server to expose the metrics.
588
start_http_server(9200, registry=registry)
589
# Generate some requests.
formatter/flake-module.nix
+1
@@ -13,6 +13,7 @@
13
programs.deadnix.enable = true;
14
programs.nixfmt.enable = true;
15
programs.nixfmt.package = pkgs.nixfmt-rfc-style;
16
+ programs.ruff-format.enable = true;
17
18
# TODO: fix shellcheck errors in a follow up pr
19
#programs.shellcheck.enable = true;
hydra-packet-importer/default.nix
+1
-5
@@ -5,16 +5,12 @@ python3.pkgs.buildPythonApplication {
5
6
format = "other";
7
8
- nativeBuildInputs = [
9
- python3.pkgs.mypy
10
- python3.pkgs.black
11
- ];
8
+ nativeBuildInputs = [ python3.pkgs.mypy ];
9
10
propagatedBuildInputs = [ python3.pkgs.packet-python ];
11
12
installPhase = ''
13
mypy ./import.py
17
- black --check ./import.py
14
mkdir -p $out/bin
15
mv import.py $out/bin/hydra-packet-importer
16
'';