A node's whole Metric registry, point-in-time — the served wire envelope.
models
Source src/Telemetry.ts:1334 lines
export class class MetricsSnapshotclass MetricsSnapshot {
ts: number;
metrics: ReadonlyArray<CounterDatum | GaugeDatum | HistogramDatum>;
}
A node's whole Metric registry, point-in-time — the served wire envelope.
MetricsSnapshot extends import SchemaSchema.const Class: <MetricsSnapshot, {}>(identifier: string) => {
<Fields>(fields: Fields, annotations?: Schema.Annotations.Declaration<MetricsSnapshot, readonly [Schema.Struct<Fields>]> | undefined): Schema.Class<MetricsSnapshot, Schema.Struct<Fields>, {}>;
<S>(schema: S, annotations?: Schema.Annotations.Declaration<MetricsSnapshot, readonly [S]> | undefined): Schema.Class<MetricsSnapshot, S, {}>;
}
Creates a schema-backed class whose constructor validates input against a
Struct
schema. Construction throws a
SchemaError
on invalid
input.
When to use
Use when you need a schema-backed data class with validated construction,
schema-derived decoding/encoding, and class-style methods or inheritance.
Details
Pass the desired class type as the first type parameter. The second optional
type parameter can be used to add nominal brands.
Gotchas
Passing disableChecks in the options skips constructor validation.
Example (Defining a basic class)
import { Schema } from "effect"
class Person extends Schema.Class<Person>("Person")({
name: Schema.String,
age: Schema.Number
}) {}
const alice = new Person({ name: "Alice", age: 30 })
console.log(alice.name) // "Alice"
console.log(`${alice}`) // "Person({ name: Alice, age: 30 })"
Example (Extending a class)
import { Schema } from "effect"
class Animal extends Schema.Class<Animal>("Animal")({
name: Schema.String
}) {}
class Dog extends Animal.extend<Dog>("Dog")({
breed: Schema.String
}) {}
const dog = new Dog({ name: "Rex", breed: "Labrador" })
console.log(dog.name) // "Rex"
console.log(dog.breed) // "Labrador"
Class<class MetricsSnapshotclass MetricsSnapshot {
ts: number;
metrics: ReadonlyArray<CounterDatum | GaugeDatum | HistogramDatum>;
}
A node's whole Metric registry, point-in-time — the served wire envelope.
MetricsSnapshot>("MetricsSnapshot")({
ts: Schema.Number(property) ts: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<number, readonly []>) => Schema.Number;
annotateKey: (annotations: Schema.Annotations.Key<number>) => Schema.Number;
check: (checks_0: Check<number>, ...checks: Array<Check<number>>) => Schema.Number;
rebuild: (ast: Number) => Schema.Number;
make: (input: number, options?: Schema.MakeOptions) => number;
makeOption: (input: number, options?: Schema.MakeOptions) => Option<number>;
makeEffect: (input: number, options?: Schema.MakeOptions) => Effect.Effect<number, Schema.SchemaError, never>;
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; <…;
}
import SchemaSchema.const Number: Schema.Numberconst Number: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<number, readonly []>) => Schema.Number;
annotateKey: (annotations: Schema.Annotations.Key<number>) => Schema.Number;
check: (checks_0: Check<number>, ...checks: Array<Check<number>>) => Schema.Number;
rebuild: (ast: Number) => Schema.Number;
make: (input: number, options?: Schema.MakeOptions) => number;
makeOption: (input: number, options?: Schema.MakeOptions) => Option<number>;
makeEffect: (input: number, options?: Schema.MakeOptions) => Effect.Effect<number, Schema.SchemaError, never>;
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; <…;
}
Type-level representation of
Number
.
Schema for number values, including NaN, Infinity, and -Infinity.
Details
Default JSON serializer:
- Finite numbers are serialized as numbers.
- Non-finite values are serialized as strings (
"NaN", "Infinity", "-Infinity").
Number,
metrics: Schema.$Array<
Schema.Union<
readonly [
typeof CounterDatum,
typeof GaugeDatum,
typeof HistogramDatum
]
>
>
(property) metrics: {
Type: ReadonlyArray<S["Type"]>;
Encoded: ReadonlyArray<S["Encoded"]>;
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: ReadonlyArray<S["Iso"]>;
value: S;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<ReadonlyArray<CounterDatum | GaugeDatum | HistogramDatum>, readonly []>) => Schema.$Array<Schema.Union<readonly [typeof CounterDatum, typeof GaugeDatum, typeof HistogramDatum]>>;
annotateKey: (annotations: Schema.Annotations.Key<ReadonlyArray<CounterDatum | GaugeDatum | HistogramDatum>>) => Schema.$Array<Schema.Union<readonly [typeof CounterDatum, typeof GaugeDatum, typeof HistogramDatum]>>;
check: (checks_0: Check<ReadonlyArray<CounterDatum | GaugeDatum | HistogramDatum>>, ...checks: Array<Check<ReadonlyArray<CounterDatum | GaugeDatum | HistogramDatum>>>) => Schema.$Array<Schema.Union<readonly [typeof CounterDatum, typeof GaugeDatum…;
rebuild: (ast: Arrays) => Schema.$Array<Schema.Union<readonly [typeof CounterDatum, typeof GaugeDatum, typeof HistogramDatum]>>;
make: (input: ReadonlyArray<CounterDatum | GaugeDatum | HistogramDatum>, options?: Schema.MakeOptions) => ReadonlyArray<CounterDatum | GaugeDatum | HistogramDatum>;
makeOption: (input: ReadonlyArray<CounterDatum | GaugeDatum | HistogramDatum>, options?: Schema.MakeOptions) => Option<ReadonlyArray<CounterDatum | GaugeDatum | HistogramDatum>>;
makeEffect: (input: ReadonlyArray<CounterDatum | GaugeDatum | HistogramDatum>, options?: Schema.MakeOptions) => Effect.Effect<ReadonlyArray<CounterDatum | GaugeDatum | HistogramDatum>, Schema.SchemaError, never>;
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; <…;
}
import SchemaSchema.Array<Schema.Union<readonly [typeof CounterDatum, typeof GaugeDatum, typeof HistogramDatum]>>(self: Schema.Union<readonly [typeof CounterDatum, typeof GaugeDatum, typeof HistogramDatum]>): Schema.$Array<Schema.Union<readonly [typeof CounterDatum, typeof GaugeDatum, typeof HistogramDatum]>>
export Array
Defines a ReadonlyArray schema for a given element schema.
Example (Defining an array of strings)
import { Schema } from "effect"
const schema = Schema.Array(Schema.String)
const result = Schema.decodeUnknownSync(schema)(["a", "b", "c"])
console.log(result)
// [ 'a', 'b', 'c' ]
Array(const metricDatum: Schema.Union<
readonly [
typeof CounterDatum,
typeof GaugeDatum,
typeof HistogramDatum
]
>
const metricDatum: {
Type: { [K in keyof Members]: Members[K]["Type"]; }[number];
Encoded: { [K in keyof Members]: Members[K]["Encoded"]; }[number];
DecodingServices: { [K in keyof Members]: Members[K]["DecodingServices"]; }[number];
EncodingServices: { [K in keyof Members]: Members[K]["EncodingServices"]; }[number];
Iso: { [K in keyof Members]: Members[K]["Iso"]; }[number];
members: Members;
mapMembers: (f: (members: readonly [typeof CounterDatum, typeof GaugeDatum, typeof HistogramDatum]) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Union<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<CounterDatum | GaugeDatum | HistogramDatum, readonly []>) => Schema.Union<readonly [typeof CounterDatum, typeof GaugeDatum, typeof HistogramDatum]>;
annotateKey: (annotations: Schema.Annotations.Key<CounterDatum | GaugeDatum | HistogramDatum>) => Schema.Union<readonly [typeof CounterDatum, typeof GaugeDatum, typeof HistogramDatum]>;
check: (checks_0: Check<CounterDatum | GaugeDatum | HistogramDatum>, ...checks: Array<Check<CounterDatum | GaugeDatum | HistogramDatum>>) => Schema.Union<readonly [typeof CounterDatum, typeof GaugeDatum, typeof HistogramDatum]>;
rebuild: (ast: Union<Declaration>) => Schema.Union<readonly [typeof CounterDatum, typeof GaugeDatum, typeof HistogramDatum]>;
make: (input: CounterDatum | GaugeDatum | HistogramDatum, options?: Schema.MakeOptions) => CounterDatum | GaugeDatum | HistogramDatum;
makeOption: (input: CounterDatum | GaugeDatum | HistogramDatum, options?: Schema.MakeOptions) => Option<CounterDatum | GaugeDatum | HistogramDatum>;
makeEffect: (input: CounterDatum | GaugeDatum | HistogramDatum, options?: Schema.MakeOptions) => Effect.Effect<CounterDatum | GaugeDatum | HistogramDatum, Schema.SchemaError, never>;
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; <…;
}
One metric from a node's registry, tagged by kind. Frequency/Summary are deferred.
metricDatum),
}) {}
Referenced by 2 symbols