<Self>(tag: TelemetryTag<Self>): Layer.Layer<
PeersId<Self> | SelfNodeId<Self>
>Discharge the mesh with no peers — this node's registry alone. Pair with layer / serve when Telemetry is not distributed:
Telemetry.layer(FleetTelemetry).pipe(Layer.provide(Telemetry.alone(FleetTelemetry)))For a fleet, provide Hyperlink.peersLayer instead (bundled selfNode + peers).
Source src/Telemetry.ts:3627 lines
export const const alone: <Self>(
tag: TelemetryTag<Self>
) => Layer.Layer<PeersId<Self> | SelfNodeId<Self>>
Discharge the mesh with no peers — this node's registry alone. Pair with
layer
/
serve
when Telemetry is not distributed:
Telemetry.layer(FleetTelemetry).pipe(Layer.provide(Telemetry.alone(FleetTelemetry)))
For a fleet, provide
Hyperlink.peersLayer
instead (bundled selfNode + peers).
alone = <function (type parameter) Self in <Self>(tag: TelemetryTag<Self>): Layer.Layer<PeersId<Self> | SelfNodeId<Self>>Self>(
tag: TelemetryTag<Self>(parameter) tag: {
key: Identifier;
Service: {
snapshot: Effect.Effect<MetricsSnapshot, never, never>;
live: Stream.Stream<MetricsSnapshot, never, never>;
inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>;
fleetInFlight: Effect.Effect<number, never, never>;
};
description: string | undefined;
of: (this: void, self: { readonly snapshot: Effect.Effect<MetricsSnapshot, never, never>; readonly live: Stream.Stream<MetricsSnapshot, never, never>; readonly inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>; read…;
context: (self: { readonly snapshot: Effect.Effect<MetricsSnapshot, never, never>; readonly live: Stream.Stream<MetricsSnapshot, never, never>; readonly inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>; readonly fleetIn…;
use: (f: (service: { readonly snapshot: Effect.Effect<MetricsSnapshot, never, never>; readonly live: Stream.Stream<MetricsSnapshot, never, never>; readonly inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>; readonly …;
useSync: (f: (service: { readonly snapshot: Effect.Effect<MetricsSnapshot, never, never>; readonly live: Stream.Stream<MetricsSnapshot, never, never>; readonly inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>; readonly …;
Identifier: Identifier;
stack: string | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
type TelemetryTag<Self> = Hyperlink.HyperlinkTag<Self, {
snapshot: Hyperlink.Method<undefined, typeof MetricsSnapshot, Schema.Never, false, Hyperlink.MethodAnnotations & {
description: string;
}, Hyperlink.Derive>;
live: Hyperlink.Method<undefined, typeof MetricsSnapshot, Schema.Never, true, Hyperlink.MethodAnnotations & {
description: string;
}, Hyperlink.Derive>;
inFlightByNode: Hyperlink.Marked<Hyperlink.Method<undefined, Schema.$Record<Schema.String, Schema.Number>, Schema.Never, false, Hyperlink.MethodAnnotations & {
...;
}, Hyperlink.Derive>, {
...;
}>;
fleetInFlight: Hyperlink.Marked<...>;
}, {
...;
}>
A Telemetry instance tag.
TelemetryTag<function (type parameter) Self in <Self>(tag: TelemetryTag<Self>): Layer.Layer<PeersId<Self> | SelfNodeId<Self>>Self>,
): import LayerLayer.interface Layer<in ROut, out E = never, out RIn = never>A Layer describes how to build one or more services for dependency injection.
When to use
Use to model construction of application services for dependency injection,
especially when services have dependencies, can fail during construction, or
need scoped setup and release.
Details
A Layer<ROut, E, RIn> represents ROut as the services this layer
provides, E as the possible errors during layer construction, and RIn as
the services this layer requires as dependencies.
Layer<interface PeersId<Self>Phantom brand for the per-HyperService
peers
capability, so distinct HyperServices' peer sets
don't collide in one context.
PeersId<function (type parameter) Self in <Self>(tag: TelemetryTag<Self>): Layer.Layer<PeersId<Self> | SelfNodeId<Self>>Self> | interface SelfNodeId<Self>Phantom brand for the per-HyperService
selfNode
capability (which node this instance runs as),
so distinct HyperServices' self-node identities don't collide in one context.
SelfNodeId<function (type parameter) Self in <Self>(tag: TelemetryTag<Self>): Layer.Layer<PeersId<Self> | SelfNodeId<Self>>Self>> =>
import LayerLayer.const merge: {
<RIn, E, ROut>(that: Layer<ROut, E, RIn>): <
RIn2,
E2,
ROut2
>(
self: Layer<ROut2, E2, RIn2>
) => Layer<ROut | ROut2, E | E2, RIn | RIn2>
<Layers extends [Any, ...Array<Any>]>(
that: Layers
): <A, E, R>(
self: Layer<A, E, R>
) => Layer<
A | Success<Layers[number]>,
E | Error<Layers[number]>,
Services<Layers[number]> | R
>
<RIn2, E2, ROut2, RIn, E, ROut>(
self: Layer<ROut2, E2, RIn2>,
that: Layer<ROut, E, RIn>
): Layer<ROut | ROut2, E | E2, RIn | RIn2>
<A, E, R, Layers extends [Any, ...Array<Any>]>(
self: Layer<A, E, R>,
that: Layers
): Layer<
A | Success<Layers[number]>,
E | Error<Layers[number]>,
Services<Layers[number]> | R
>
}
Merges this layer with another layer concurrently, producing a new layer with
combined input, error, and output types.
When to use
Use to combine an existing Layer with another Layer or an array of
layers while preserving pipeline style.
Details
This is a binary version of mergeAll that merges exactly two layers or one
layer with an array of layers. The layers are built concurrently and their
outputs are combined.
Example (Merging two layers)
import { Context, Effect, Layer } from "effect"
class Database extends Context.Service<Database, {
readonly query: (sql: string) => Effect.Effect<string>
}>()("Database") {}
class Logger extends Context.Service<Logger, {
readonly log: (msg: string) => Effect.Effect<void>
}>()("Logger") {}
const dbLayer = Layer.succeed(Database, {
query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
})
const loggerLayer = Layer.succeed(Logger, {
log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
})
const mergedLayer = Layer.merge(dbLayer, loggerLayer)
merge(
import HyperlinkHyperlink.const peersFrom: <Self, S extends Spec>(
tag: HyperlinkTag<Self, S>,
peers: Record<string, PeerServiceOf<S>>
) => Layer.Layer<PeersId<Self>>
Provide the
peers
capability from an explicit client map — for a holder that already
holds the per-node clients (a dashboard's per-node bundles), or for a test.
peersLayer
is
the auto-connecting form (from the tag's distributed set + urls); this one takes the clients as-is.
peersFrom(tag: TelemetryTag<Self>(parameter) tag: {
key: Identifier;
Service: {
snapshot: Effect.Effect<MetricsSnapshot, never, never>;
live: Stream.Stream<MetricsSnapshot, never, never>;
inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>;
fleetInFlight: Effect.Effect<number, never, never>;
};
description: string | undefined;
of: (this: void, self: { readonly snapshot: Effect.Effect<MetricsSnapshot, never, never>; readonly live: Stream.Stream<MetricsSnapshot, never, never>; readonly inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>; read…;
context: (self: { readonly snapshot: Effect.Effect<MetricsSnapshot, never, never>; readonly live: Stream.Stream<MetricsSnapshot, never, never>; readonly inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>; readonly fleetIn…;
use: (f: (service: { readonly snapshot: Effect.Effect<MetricsSnapshot, never, never>; readonly live: Stream.Stream<MetricsSnapshot, never, never>; readonly inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>; readonly …;
useSync: (f: (service: { readonly snapshot: Effect.Effect<MetricsSnapshot, never, never>; readonly live: Stream.Stream<MetricsSnapshot, never, never>; readonly inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>; readonly …;
Identifier: Identifier;
stack: string | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
import HyperlinkHyperlink.const selfNodeLayer: <
Self,
S extends Spec
>(
tag: HyperlinkTag<Self, S>,
self: AnyNode
) => Layer.Layer<SelfNodeId<Self>>
Provide the
selfNode
capability on this node — the node key this instance runs as. Bundled
into
peersLayer
(so a mesh resource gets it for free); use this standalone when a HyperService
keys per node but doesn't gather peers, or alongside
peersFrom
in a test. No transport, no
failure path — just the identity.
selfNodeLayer(tag: TelemetryTag<Self>(parameter) tag: {
key: Identifier;
Service: {
snapshot: Effect.Effect<MetricsSnapshot, never, never>;
live: Stream.Stream<MetricsSnapshot, never, never>;
inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>;
fleetInFlight: Effect.Effect<number, never, never>;
};
description: string | undefined;
of: (this: void, self: { readonly snapshot: Effect.Effect<MetricsSnapshot, never, never>; readonly live: Stream.Stream<MetricsSnapshot, never, never>; readonly inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>; read…;
context: (self: { readonly snapshot: Effect.Effect<MetricsSnapshot, never, never>; readonly live: Stream.Stream<MetricsSnapshot, never, never>; readonly inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>; readonly fleetIn…;
use: (f: (service: { readonly snapshot: Effect.Effect<MetricsSnapshot, never, never>; readonly live: Stream.Stream<MetricsSnapshot, never, never>; readonly inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>; readonly …;
useSync: (f: (service: { readonly snapshot: Effect.Effect<MetricsSnapshot, never, never>; readonly live: Stream.Stream<MetricsSnapshot, never, never>; readonly inFlightByNode: Effect.Effect<{ readonly [x: string]: number }, never, never>; readonly …;
Identifier: Identifier;
stack: string | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
class TelemetryAloneNodeclass TelemetryAloneNode {
key: Identifier;
Service: {
protocol: Context.Service.Shape<typeof RpcClient.Protocol>;
ping: Effect.Effect<number, NodeUnreachable>;
status: { readonly get: Effect.Effect<NodeStatusSnapshot, NodeUnreachable>; readonly changes: Stream.Stream<NodeStatusSnapshot, NodeUnreachable> };
logs: { readonly stream: Stream.Stream<LogEntry, NodeUnreachable>; readonly query: (options: { readonly limit: number }) => Effect.Effect<ReadonlyArray<LogEntry>, NodeUnreachable> };
};
of: (this: void, self: NodeProtocol) => NodeProtocol;
context: (self: NodeProtocol) => Context<TelemetryAloneNode>;
use: (f: (service: NodeProtocol) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, TelemetryAloneNode | R>;
useSync: (f: (service: NodeProtocol) => A) => Effect.Effect<A, never, TelemetryAloneNode>;
Identifier: Identifier;
stack: string | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
url: undefined;
path: undefined;
kind: undefined;
logs: unknown;
onConflict: OnConflict;
}
Identity node for a non-meshed Telemetry instance (no peers). Used by
alone
.
TelemetryAloneNode),
);