FrequencyA Frequency metric interface that counts occurrences of discrete string values.
When to use
Use when frequency metrics are ideal for tracking categorical data where you want to count how many times specific string values occur, such as HTTP status codes, user actions, error types, or any discrete string-based events.
Example (Using frequency metrics)
import { Data, Effect, Metric } from "effect"
class FrequencyInterfaceError
extends Data.TaggedError("FrequencyInterfaceError")<{
readonly operation: string
}>
{}
// Function that accepts any Frequency metric
const logFrequencyMetric = (freq: Metric.Frequency) =>
Effect.gen(function*() {
const state = yield* Metric.value(freq)
yield* Effect.log(`Frequency Metric: ${freq.id}`)
yield* Effect.log(`Description: ${freq.description ?? "No description"}`)
yield* Effect.log(`Type: ${freq.type}`) // "Frequency"
// Access the frequency state
const occurrences: ReadonlyMap<string, number> = state.occurrences
yield* Effect.log(`Total unique values: ${occurrences.size}`)
// Iterate through all occurrences
for (const [value, count] of occurrences) {
yield* Effect.log(` "${value}": ${count} occurrences`)
}
// Find most frequent value
let maxCount = 0
let mostFrequent = ""
for (const [value, count] of occurrences) {
if (count > maxCount) {
maxCount = count
mostFrequent = value
}
}
return { mostFrequent, maxCount, totalUniqueValues: occurrences.size }
})
const program = Effect.gen(function*() {
// Create frequency metrics
const statusCodes: Metric.Frequency = Metric.frequency("http_status", {
description: "HTTP status code frequency"
})
const userActions: Metric.Frequency = Metric.frequency("user_actions", {
description: "User action frequency"
})
// Record some occurrences
yield* Metric.update(statusCodes, "200")
yield* Metric.update(statusCodes, "200")
yield* Metric.update(statusCodes, "404")
yield* Metric.update(statusCodes, "500")
yield* Metric.update(statusCodes, "200")
yield* Metric.update(userActions, "login")
yield* Metric.update(userActions, "view_dashboard")
yield* Metric.update(userActions, "login")
// Use the function with different frequency metrics
const statusAnalysis = yield* logFrequencyMetric(statusCodes)
const actionAnalysis = yield* logFrequencyMetric(userActions)
return { statusAnalysis, actionAnalysis }
})metrics
Source effect/Metric.ts:3361 lines
export interface Frequency extends interface Metric<in Input, out State>A Metric<Input, State> represents a concurrent metric which accepts update
values of type Input and are aggregated to a value of type State.
Details
For example, a counter metric would have type Metric<number, number>,
representing the fact that the metric can be updated with numbers (the amount
to increment or decrement the counter by), and the state of the counter is a
number.
There are five primitive metric types supported by Effect:
- Counters
- Frequencies
- Gauges
- Histograms
- Summaries
Example (Using multiple metric types)
import { Data, Effect, Metric } from "effect"
class MetricExample extends Data.TaggedError("MetricExample")<{
readonly operation: string
}> {}
const program = Effect.gen(function*() {
// Create different types of metrics
const requestCounter: Metric.Counter<number> = Metric.counter("requests", {
description: "Total requests processed"
})
const memoryGauge: Metric.Gauge<number> = Metric.gauge("memory_usage", {
description: "Current memory usage in MB"
})
const statusFrequency: Metric.Frequency = Metric.frequency("status_codes", {
description: "HTTP status code frequency"
})
// All metrics share the same interface for updates and reads
yield* Metric.update(requestCounter, 1)
yield* Metric.update(memoryGauge, 128)
yield* Metric.update(statusFrequency, "200")
// All metrics can be read with Metric.value
const counterState = yield* Metric.value(requestCounter)
const gaugeState = yield* Metric.value(memoryGauge)
const frequencyState = yield* Metric.value(statusFrequency)
// Metrics have common properties accessible through the interface:
// - id: unique identifier
// - type: metric type ("Counter", "Gauge", "Frequency", etc.)
// - description: optional human-readable description
// - attributes: optional key-value attributes for tagging
return {
counter: {
id: requestCounter.id,
type: requestCounter.type,
state: counterState
},
gauge: { id: memoryGauge.id, type: memoryGauge.type, state: gaugeState },
frequency: {
id: statusFrequency.id,
type: statusFrequency.type,
state: frequencyState
}
}
})
The Metric namespace provides a comprehensive system for collecting, aggregating, and observing
application metrics in Effect applications.
Example (Collecting application metrics)
import { Data, Effect, Metric } from "effect"
class MetricsError extends Data.TaggedError("MetricsError")<{
readonly operation: string
}> {}
const program = Effect.gen(function*() {
// Create different types of metrics
const requestCounter = Metric.counter("http_requests_total")
const responseTimeHistogram = Metric.histogram("http_response_time", {
boundaries: Metric.linearBoundaries({ start: 0, width: 10, count: 10 })
})
const activeConnectionsGauge = Metric.gauge("active_connections")
const statusFrequency = Metric.frequency("http_status_codes")
// Update metrics
yield* Metric.update(requestCounter, 1)
yield* Metric.update(responseTimeHistogram, 45.2)
yield* Metric.update(activeConnectionsGauge, 12)
yield* Metric.update(statusFrequency, "200")
// Get metric values
const counterValue = yield* Metric.value(requestCounter)
const histogramValue = yield* Metric.value(responseTimeHistogram)
const gaugeValue = yield* Metric.value(activeConnectionsGauge)
const frequencyValue = yield* Metric.value(statusFrequency)
return {
counter: counterValue,
histogram: histogramValue,
gauge: gaugeValue,
frequency: frequencyValue
}
})
Metric<string, FrequencyState> {}Referenced by 2 symbols