|
| 1 | +import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; |
| 2 | +import * as NodeServices from "@effect/platform-node/NodeServices"; |
1 | 3 | import type { HostPowerSnapshot } from "@t3tools/contracts"; |
| 4 | +import { |
| 5 | + RESOURCE_MONITOR_PROTOCOL_VERSION, |
| 6 | + ResourceMonitorCommand, |
| 7 | + type ResourceMonitorHelloEvent, |
| 8 | +} from "@t3tools/contracts"; |
2 | 9 | import { describe, expect, it } from "@effect/vitest"; |
3 | 10 | import * as DateTime from "effect/DateTime"; |
4 | 11 | import * as Deferred from "effect/Deferred"; |
5 | 12 | import * as Effect from "effect/Effect"; |
| 13 | +import * as Exit from "effect/Exit"; |
6 | 14 | import * as Fiber from "effect/Fiber"; |
| 15 | +import * as Layer from "effect/Layer"; |
| 16 | +import * as Queue from "effect/Queue"; |
7 | 17 | import * as Ref from "effect/Ref"; |
| 18 | +import * as Schema from "effect/Schema"; |
| 19 | +import * as Scope from "effect/Scope"; |
8 | 20 | import * as Semaphore from "effect/Semaphore"; |
| 21 | +import * as Sink from "effect/Sink"; |
| 22 | +import * as Stream from "effect/Stream"; |
| 23 | +import { ChildProcessSpawner } from "effect/process"; |
9 | 24 |
|
| 25 | +import * as ServerConfig from "../config.ts"; |
| 26 | +import * as NativeTelemetryClient from "./NativeTelemetryClient.ts"; |
| 27 | +import * as ResourceMonitorBinary from "./ResourceMonitorBinary.ts"; |
10 | 28 | import { |
11 | 29 | canCommandNativeTelemetrySidecar, |
12 | 30 | canRequestNativeTelemetryRetry, |
@@ -40,25 +58,106 @@ describe("resolveNativeSampleIntervalMs", () => { |
40 | 58 | expect(resolveNativeSampleIntervalMs({ ...basePower, onBattery: "true" }, 1)).toBe(5_000); |
41 | 59 | }); |
42 | 60 |
|
43 | | - it("slows background telemetry and serves live diagnostics at 1Hz", () => { |
| 61 | + it("stops timed sampling without a live subscriber and serves live diagnostics at 1Hz", () => { |
44 | 62 | const unknown: HostPowerSnapshot = { |
45 | 63 | ...basePower, |
46 | 64 | source: "unknown", |
47 | 65 | stale: true, |
48 | 66 | }; |
49 | | - expect(resolveNativeSampleIntervalMs(unknown, 0)).toBe(5_000); |
| 67 | + expect(resolveNativeSampleIntervalMs(unknown, 0)).toBe(0); |
50 | 68 | expect(resolveNativeSampleIntervalMs(unknown, 1)).toBe(1_000); |
51 | | - expect( |
52 | | - resolveNativeSampleIntervalMs( |
53 | | - { ...basePower, stale: true, locked: "true", suspended: true }, |
54 | | - 0, |
55 | | - ), |
56 | | - ).toBe(5_000); |
57 | | - expect(resolveNativeSampleIntervalMs(basePower, 0)).toBe(5_000); |
| 69 | + expect(resolveNativeSampleIntervalMs({ ...basePower, locked: "true" }, 0)).toBe(0); |
| 70 | + expect(resolveNativeSampleIntervalMs({ ...basePower, onBattery: "true" }, 0)).toBe(0); |
| 71 | + expect(resolveNativeSampleIntervalMs(basePower, 0)).toBe(0); |
58 | 72 | expect(resolveNativeSampleIntervalMs(basePower, 1)).toBe(1_000); |
59 | 73 | }); |
60 | 74 | }); |
61 | 75 |
|
| 76 | +const decodeCommandLine = Schema.decodeUnknownSync(Schema.fromJsonString(ResourceMonitorCommand)); |
| 77 | + |
| 78 | +const hello: ResourceMonitorHelloEvent = { |
| 79 | + version: RESOURCE_MONITOR_PROTOCOL_VERSION, |
| 80 | + type: "hello", |
| 81 | + sidecarVersion: "test", |
| 82 | + sidecarPid: 4242, |
| 83 | + platform: "linux", |
| 84 | + arch: "x64", |
| 85 | + capabilities: { |
| 86 | + cumulativeCpuTime: true, |
| 87 | + currentCpuPercent: true, |
| 88 | + residentMemory: true, |
| 89 | + virtualMemory: true, |
| 90 | + ioBytes: true, |
| 91 | + processStartTime: true, |
| 92 | + processTree: true, |
| 93 | + }, |
| 94 | +}; |
| 95 | + |
| 96 | +describe("NativeTelemetryClient", () => { |
| 97 | + it.effect("asks the sidecar for timed samples only while a live subscriber exists", () => |
| 98 | + Effect.gen(function* () { |
| 99 | + const commands = yield* Queue.unbounded<ResourceMonitorCommand>(); |
| 100 | + // A sidecar that says hello, stays alive, and records every command it receives. |
| 101 | + const spawner = ChildProcessSpawner.make(() => |
| 102 | + Effect.succeed( |
| 103 | + ChildProcessSpawner.makeHandle({ |
| 104 | + pid: ChildProcessSpawner.ProcessId(hello.sidecarPid), |
| 105 | + exitCode: Effect.never, |
| 106 | + isRunning: Effect.succeed(true), |
| 107 | + kill: () => Effect.void, |
| 108 | + unref: Effect.succeed(Effect.void), |
| 109 | + stdin: Sink.forEach((chunk: Uint8Array) => |
| 110 | + Effect.forEach(new TextDecoder().decode(chunk).split("\n").filter(Boolean), (line) => |
| 111 | + Queue.offer(commands, decodeCommandLine(line)), |
| 112 | + ), |
| 113 | + ), |
| 114 | + stdout: Stream.encodeText(Stream.make(`${JSON.stringify(hello)}\n`)).pipe( |
| 115 | + Stream.concat(Stream.never), |
| 116 | + ), |
| 117 | + stderr: Stream.empty, |
| 118 | + all: Stream.empty, |
| 119 | + getInputFd: () => Sink.drain, |
| 120 | + getOutputFd: () => Stream.empty, |
| 121 | + }), |
| 122 | + ), |
| 123 | + ); |
| 124 | + const client = yield* NativeTelemetryClient.make().pipe( |
| 125 | + Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), |
| 126 | + Effect.provideService(ResourceMonitorBinary.ResourceMonitorBinary, { |
| 127 | + resolve: Effect.succeed("/test/t3-resource-monitor"), |
| 128 | + }), |
| 129 | + ); |
| 130 | + |
| 131 | + const configure = yield* Queue.take(commands); |
| 132 | + expect(configure).toMatchObject({ type: "configure", sampleIntervalMs: 0 }); |
| 133 | + expect(yield* Queue.take(commands)).toMatchObject({ type: "setExternalProcesses" }); |
| 134 | + |
| 135 | + const live = yield* Scope.make(); |
| 136 | + yield* client.snapshots.pipe(Stream.runDrain, Effect.forkIn(live)); |
| 137 | + expect(yield* Queue.take(commands)).toMatchObject({ |
| 138 | + type: "setSampleInterval", |
| 139 | + sampleIntervalMs: 1_000, |
| 140 | + }); |
| 141 | + expect(yield* Queue.take(commands)).toMatchObject({ type: "setStreaming", enabled: true }); |
| 142 | + |
| 143 | + yield* Scope.close(live, Exit.void); |
| 144 | + expect(yield* Queue.take(commands)).toMatchObject({ |
| 145 | + type: "setSampleInterval", |
| 146 | + sampleIntervalMs: 0, |
| 147 | + }); |
| 148 | + expect(yield* Queue.take(commands)).toMatchObject({ type: "setStreaming", enabled: false }); |
| 149 | + expect((yield* client.health).sampleIntervalMs).toBe(0); |
| 150 | + }).pipe( |
| 151 | + Effect.provide( |
| 152 | + Layer.mergeAll( |
| 153 | + ServerConfig.layerTest(process.cwd(), { prefix: "t3-native-telemetry-test-" }), |
| 154 | + NodeCrypto.layer, |
| 155 | + ).pipe(Layer.provideMerge(NodeServices.layer)), |
| 156 | + ), |
| 157 | + ), |
| 158 | + ); |
| 159 | +}); |
| 160 | + |
62 | 161 | describe("canRequestNativeTelemetryRetry", () => { |
63 | 162 | it("only accepts retry while the supervisor is waiting without a live sidecar", () => { |
64 | 163 | expect(canRequestNativeTelemetryRetry("degraded", false)).toBe(true); |
|
0 commit comments