<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).
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>tag: type TelemetryTag<Self> = HyperlinkTag<
Self,
{
snapshot: any
live: any
inFlightByNode: any
fleetInFlight: any
}
>
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<import PeersIdPeersId<function (type parameter) Self in <Self>(tag: TelemetryTag<Self>): Layer.Layer<PeersId<Self> | SelfNodeId<Self>>Self> | import SelfNodeIdSelfNodeId<function (type parameter) Self in <Self>(tag: TelemetryTag<Self>): Layer.Layer<PeersId<Self> | SelfNodeId<Self>>Self>> =>
import LayerLayer.const merge: <never, never, any, never, never, any>(self: Layer.Layer<any, never, never>, that: Layer.Layer<any, never, never>) => Layer.Layer<any, never, never> (+3 overloads)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.peersFrom(tag: TelemetryTag<Self>tag, {}),
import HyperlinkHyperlink.selfNodeLayer(tag: TelemetryTag<Self>tag, class TelemetryAloneNodeIdentity node for a non-meshed Telemetry instance (no peers). Used by
alone
.
TelemetryAloneNode),
);