model

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Dec 14, 2022 License: Apache-2.0 Imports: 9 Imported by: 0

Documentation

Overview

Package model provides Go structs describing the APM output data model, and methods for encoding them to the Elasticsearch document JSON structure.

Index

Constants

This section is empty.

Variables

View Source
var (
	// ErrorProcessor is the Processor value that should be assigned to error events.
	ErrorProcessor = Processor{Name: "error", Event: "error"}
)
View Source
var (
	// LogProcessor is the Processor value that should be assigned to log events.
	LogProcessor = Processor{Name: "log", Event: "log"}
)
View Source
var (
	// MetricsetProcessor is the Processor value that should be assigned to metricset events.
	MetricsetProcessor = Processor{Name: "metric", Event: "metric"}
)
View Source
var (
	// SpanProcessor is the Processor value that should be assigned to span events.
	SpanProcessor = Processor{Name: "transaction", Event: "span"}
)
View Source
var (
	// TransactionProcessor is the Processor value that should be assigned to transaction events.
	TransactionProcessor = Processor{Name: "transaction", Event: "transaction"}
)

Functions

This section is empty.

Types

type APMEvent

type APMEvent struct {
	// DataStream optionally holds data stream identifiers.
	DataStream DataStream

	Event       Event
	Agent       Agent
	Observer    Observer
	Container   Container
	Kubernetes  Kubernetes
	Service     Service
	Process     Process
	Device      Device
	Host        Host
	User        User
	UserAgent   UserAgent
	Client      Client
	Source      Source
	Destination Destination
	Cloud       Cloud
	Network     Network
	Session     Session
	URL         URL
	Processor   Processor
	Trace       Trace
	Parent      Parent
	Child       Child
	HTTP        HTTP
	FAAS        FAAS
	Log         Log

	// Timestamp holds the event timestamp.
	//
	// See https://www.elastic.co/guide/en/ecs/current/ecs-base.html#field-timestamp
	Timestamp time.Time

	// Labels holds the string (keyword) labels to apply to the event, stored as
	// keywords. Supports slice values.
	//
	// See https://www.elastic.co/guide/en/ecs/current/ecs-base.html#field-labels
	Labels Labels

	// NumericLabels holds the numeric (scaled_float) labels to apply to the event.
	// Supports slice values.
	NumericLabels NumericLabels

	// Message holds the message for log events.
	//
	// See https://www.elastic.co/guide/en/ecs/current/ecs-base.html#field-message
	Message string

	Transaction *Transaction
	Span        *Span
	Metricset   *Metricset
	Error       *Error
}

APMEvent holds the details of an APM event.

Exactly one of the event fields should be non-nil.

func (*APMEvent) MarshalFastJSON

func (e *APMEvent) MarshalFastJSON(w *fastjson.Writer) error

MarshalFastJSON marshals e as JSON, writing the result to w.

func (*APMEvent) MarshalJSON

func (e *APMEvent) MarshalJSON() ([]byte, error)

MarshalJSON marshals e as JSON.

type Agent

type Agent struct {
	Name        string
	Version     string
	EphemeralID string
}

Agent describes an Elastic APM agent.

type AggregatedDuration

type AggregatedDuration struct {
	// Count holds the number of durations aggregated.
	Count int

	// Sum holds the sum of aggregated durations.
	Sum time.Duration
}

AggregatedDuration holds a count and sum of aggregated durations.

type Batch

type Batch []APMEvent

Batch is a collection of APM events.

type BatchProcessor

type BatchProcessor interface {
	// ProcessBatch is called with a batch of events for processing.
	//
	// Processing may involve anything, e.g. modifying, adding, removing,
	// aggregating, or publishing events.
	//
	// The caller should not assume the batch to be valid after the
	// method has returned.
	// If the batch needs to be processed asynchronously or kept around,
	// the processor must create a copy of the slice.
	ProcessBatch(context.Context, *Batch) error
}

BatchProcessor can be used to process a batch of events, giving the opportunity to update, add or remove events.

type Child

type Child struct {
	// ID holds IDs of child events.
	ID []string
}

Child holds information about the children of a trace event.

type Client

type Client struct {
	// Domain holds the client's domain (FQDN).
	Domain string

	// IP holds the client's IP address.
	IP netip.Addr

	// Port holds the client's IP port.
	Port int
}

Client holds information about the client of a request.

type Cloud

type Cloud struct {
	AccountID        string
	AccountName      string
	AvailabilityZone string
	InstanceID       string
	InstanceName     string
	MachineType      string
	ProjectID        string
	ProjectName      string
	Provider         string
	Region           string
	ServiceName      string

	Origin *CloudOrigin
}

Cloud holds information about the cloud computing environment in which a service is running.

type CloudOrigin

type CloudOrigin struct {
	AccountID   string
	Provider    string
	Region      string
	ServiceName string
}

type Composite

type Composite struct {
	Count               int
	Sum                 float64 // milliseconds
	CompressionStrategy string
}

Composite holds details on a group of spans compressed into one.

type Container

type Container struct {
	ID        string
	Name      string
	Runtime   string
	ImageName string
	ImageTag  string
}

type DB

type DB struct {
	Instance     string
	Statement    string
	Type         string
	UserName     string
	Link         string
	RowsAffected *int
}

DB contains information related to a database query of a span event

type DataStream

type DataStream struct {
	// Type holds the data_stream.type identifier.
	Type string

	// Dataset holds the data_stream.dataset identifier.
	Dataset string

	// Namespace holds the data_stream.namespace identifier.
	Namespace string
}

DataStream identifies the data stream to which an event will be written.

type Destination

type Destination struct {
	Address string
	Port    int
}

Destination holds information about the destination of a request.

type DestinationService

type DestinationService struct {
	Type     string // Deprecated
	Name     string // Deprecated
	Resource string // Deprecated

	// ResponseTime holds aggregated span durations for the destination service resource.
	ResponseTime AggregatedDuration
}

DestinationService contains information about the destination service of a span event

type Device

type Device struct {
	// ID holds the unique identifier of a device.
	ID string

	// Model holds information about the device model.
	Model DeviceModel

	// Manufacturer the vendor name of the device manufacturer.
	Manufacturer string
}

type DeviceModel

type DeviceModel struct {
	// Name holds the human readable marketing name of the device model.
	Name string

	// Identifier holds the machine readable identifier of the device model.
	Identifier string
}

type DroppedSpanStats

type DroppedSpanStats struct {
	DestinationServiceResource string
	ServiceTargetType          string
	ServiceTargetName          string
	Outcome                    string
	Duration                   AggregatedDuration
}

type Error

type Error struct {
	ID string

	GroupingKey string
	Culprit     string
	Custom      map[string]any

	// StackTrace holds an unparsed stack trace.
	//
	// This may be set when a stack trace cannot be parsed.
	StackTrace string

	// Message holds an error message.
	//
	// Message is the ECS field equivalent of the APM field `error.log.message`.
	Message string

	// Type holds the type of the error.
	Type string

	Exception *Exception
	Log       *ErrorLog
}

type ErrorLog

type ErrorLog struct {
	Message      string
	Level        string
	ParamMessage string
	LoggerName   string
	Stacktrace   Stacktrace
}

type Event

type Event struct {
	// Duration holds the event duration.
	//
	// Duration is only added as a field (`duration`) if greater than zero.
	Duration time.Duration

	// Outcome holds the event outcome: "success", "failure", or "unknown".
	Outcome string

	// Severity holds the numeric severity of the event for log events.
	Severity int64

	// Action holds the action captured by the event for log events.
	Action string

	// Dataset holds the the dataset which produces the events. If an event
	// source publishes more than one type of log or events (e.g. access log,
	// error log), the dataset is used to specify which one the event comes from.
	Dataset string
}

Event holds information about an event, in ECS terms.

https://www.elastic.co/guide/en/ecs/current/ecs-event.html

type Exception

type Exception struct {
	Message    string
	Module     string
	Code       string
	Attributes interface{}
	Stacktrace Stacktrace
	Type       string
	Handled    *bool
	Cause      []Exception
}

type FAAS

type FAAS struct {
	ID               string
	Coldstart        *bool
	Execution        string
	TriggerType      string
	TriggerRequestID string
	Name             string
	Version          string
}

FAAS holds information about a function as a service.

type Framework

type Framework struct {
	Name    string
	Version string
}

Framework has an optional version and name

type HTTP

type HTTP struct {
	Version  string
	Request  *HTTPRequest
	Response *HTTPResponse
}

HTTP holds information about an HTTP request and/or response.

type HTTPRequest

type HTTPRequest struct {
	ID       string
	Method   string
	Referrer string
	Body     interface{}

	Headers map[string]any
	Env     map[string]any
	Cookies map[string]any
}

HTTPRequest holds information about an HTTP request.

type HTTPResponse

type HTTPResponse struct {
	StatusCode int

	Headers         map[string]any
	Finished        *bool
	HeadersSent     *bool
	TransferSize    *int
	EncodedBodySize *int
	DecodedBodySize *int
}

HTTPResponse holds information about an HTTP response.

type Histogram

type Histogram struct {
	// Values holds the bucket values for histogram metrics.
	//
	// These values must be provided in ascending order.
	Values []float64

	// Counts holds the bucket counts for histogram metrics.
	//
	// These numbers must be positive or zero.
	//
	// If Counts is specified, then Values is expected to be
	// specified with the same number of elements, and with the
	// same order.
	Counts []int64
}

Histogram holds bucket values and counts for a histogram metric.

type Host

type Host struct {
	// Hostname holds the detected hostname of the host.
	Hostname string

	// Name holds the user-defined name of the host, or the
	// detected hostname.
	Name string

	// ID holds a unique ID for the host.
	ID string

	// Architecture holds the host machine architecture.
	Architecture string

	// Type holds the host type, e.g. cloud instance machine type.
	Type string

	// IP holds the IP addresses of the host.
	IP []netip.Addr

	// OS holds information about the operating system running on the host.
	OS OS
}

type Kubernetes

type Kubernetes struct {
	Namespace string
	NodeName  string
	PodName   string
	PodUID    string
}

type LabelValue

type LabelValue struct {
	// Value holds the label `string` value.
	Value string

	// Values holds the label `[]string` value.
	Values []string

	// Global is `true` when the label is defined at the agent level, rather
	// than being event-specific.
	Global bool
}

LabelValue wraps a `string` or `[]slice` to be set as a value for a key. Only one should be set, in cases where both are set, the `Values` field will be used and `Value` will be ignored.

type Labels

type Labels map[string]LabelValue

Labels wraps a map[string]string or map[string][]string with utility methods.

func (Labels) Clone

func (l Labels) Clone() Labels

Clone creates a deep copy of Labels.

func (Labels) Set

func (l Labels) Set(k string, v string)

Set sets the label k to value v. If there existed a label in l with the same key, it will be replaced and its Global field will be set to false.

func (Labels) SetSlice

func (l Labels) SetSlice(k string, v []string)

SetSlice sets the label k to value v. If there existed a label in l with the same key, it will be replaced and its Global field will be set to false.

type Language

type Language struct {
	Name    string
	Version string
}

Language has an optional version and name

type Log

type Log struct {
	// Level holds the log level of the log event.
	Level string
	// Logger holds the name of the logger instance.
	Logger string
	Origin LogOrigin
}

Log holds information about a log, as defined by ECS.

https://www.elastic.co/guide/en/ecs/current/ecs-log.html

type LogOrigin

type LogOrigin struct {
	File         LogOriginFile
	FunctionName string
}

LogOrigin holds information about the origin of the log.

type LogOriginFile

type LogOriginFile struct {
	Name string
	Line int
}

LogOriginFile holds information about the file and the line of the origin of the log.

type LongtaskMetrics

type LongtaskMetrics struct {
	// Count holds the number of longtasks, or a negative value if unknown.
	Count int

	// Sum holds the sum of longtask durations.
	Sum float64

	// Max holds the maximum longtask duration.
	Max float64
}

LongtaskMetrics holds metrics related to RUM longtasks.

type Message

type Message struct {
	Body       string
	Headers    http.Header
	AgeMillis  *int
	QueueName  string
	RoutingKey string
}

Message holds information about a recorded message, such as the message body and meta information

func (*Message) Fields

func (m *Message) Fields() map[string]any

Fields returns a MapStr holding the transformed message information

type MetricType

type MetricType string

MetricType describes the type of a metric: gauge, counter, or histogram.

const (
	MetricTypeGauge     MetricType = "gauge"
	MetricTypeCounter   MetricType = "counter"
	MetricTypeHistogram MetricType = "histogram"
	MetricTypeSummary   MetricType = "summary"
)

Valid MetricType values.

type Metricset

type Metricset struct {
	// Samples holds the metrics in the set.
	Samples []MetricsetSample

	// Name holds an optional name for the metricset.
	Name string

	// DocCount holds the document count for pre-aggregated metrics.
	//
	// See https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-doc-count-field.html
	DocCount int64
}

Metricset describes a set of metrics and associated metadata.

type MetricsetSample

type MetricsetSample struct {
	// Type holds an optional metric type.
	//
	// If Type is unspecified or invalid, it will be ignored.
	Type MetricType

	// Name holds the metric name.
	//
	// Name is required.
	Name string

	// Unit holds an optional unit:
	//
	// - "percent" (value is in the range [0,1])
	// - "byte"
	// - a time unit: "nanos", "micros", "ms", "s", "m", "h", "d"
	//
	// If Unit is unspecified or invalid, it will be ignored.
	Unit string

	// Value holds the metric value for single-value metrics.
	//
	// If Counts and Values are specified, then Value will be ignored.
	Value float64

	// Histogram holds bucket values and counts for histogram metrics.
	Histogram

	// SummaryMetric holds a combined count and sum of aggregated
	// measurements.
	SummaryMetric
}

MetricsetSample represents a single named metric.

type NAT

type NAT struct {
	// IP holds the translated IP address.
	IP netip.Addr
}

NAT holds information about the translated source of a network exchange.

type Network

type Network struct {
	// Connection holds information about a network connection.
	Connection NetworkConnection

	// Carrier holds information about a connection carrier.
	Carrier NetworkCarrier
}

type NetworkCarrier

type NetworkCarrier struct {
	// Name holds the carrier's name.
	Name string

	// MCC holds the carrier's mobile country code.
	MCC string

	// MNC holds the carrier's mobile network code.
	MNC string

	// ICC holds the carrier's ISO 3166-1 alpha-2 2-character country code.
	ICC string
}

type NetworkConnection

type NetworkConnection struct {
	// Type holds the connection type category,
	// e.g. "wifi", "wired", and "cell".
	Type string

	// Subtype holds more details of the connection type,
	// specific to the connection type category.
	//
	// For example, if ConnectionType is "cell" then ConnectionSubtype
	// may hold the cell technology, e.g. "LTE", or "GRPS".
	Subtype string
}

type NumericLabelValue

type NumericLabelValue struct {
	// Values holds holds the label `[]float64` value.
	Values []float64

	// Value holds the label `float64` value.
	Value float64

	// Global is `true` when the label is defined at the agent level, rather
	// than being event-specific.
	Global bool
}

NumericLabelValue wraps a `float64` or `[]float64` to be set as a value for a key. Only one should be set, in cases where both are set, the `Values` field will be used and `Value` will be ignored.

type NumericLabels

type NumericLabels map[string]NumericLabelValue

NumericLabels wraps a map[string]float64 or map[string][]float64 with utility methods.

func (NumericLabels) Clone

func (l NumericLabels) Clone() NumericLabels

Clone creates a deep copy of NumericLabels.

func (NumericLabels) Set

func (l NumericLabels) Set(k string, v float64)

Set sets the label k to value v. If there existed a label in l with the same key, it will be replaced and its Global field will be set to false.

func (NumericLabels) SetSlice

func (l NumericLabels) SetSlice(k string, v []float64)

SetSlice sets the label k to value v. If there existed a label in l with the same key, it will be replaced and its Global field will be set to false.

type OS

type OS struct {
	// Name holds the operating system name, e.g. Android.
	Name string

	// Version holds the operating system version, e.g. 15.5.0.
	Version string

	// Platform holds the operating system platform, e.g. centos, ubuntu, windows.
	Platform string

	// Full holds the full operating system name, including the version or code name.
	Full string

	// Type categorizes the operating system into one of the broad commercial families.
	//
	// If specified, Type must beone of the following (lowercase): linux, macos, unix, windows.
	// If the OS you’re dealing with is not in the list, the field should not be populated.
	Type string
}

OS holds information about the operating system.

type Observer

type Observer struct {
	Hostname string
	Name     string
	Type     string
	Version  string
}

Observer describes a special network, security, or application device used to detect, observe, or create network, security, or application-related events and metrics.

https://www.elastic.co/guide/en/ecs/current/ecs-observer.html

func (*Observer) Fields

func (o *Observer) Fields() map[string]any

type Original

type Original struct {
	AbsPath      string
	Filename     string
	Classname    string
	Lineno       *int
	Colno        *int
	Function     string
	LibraryFrame bool
}

type Parent

type Parent struct {
	// ID holds the ID of the parent event.
	ID string
}

Parent holds information about the parent of a trace event.

type Process

type Process struct {
	Pid         int
	Ppid        *int
	Title       string
	Argv        []string
	CommandLine string
	Executable  string
	Thread      ProcessThread
}

type ProcessBatchFunc

type ProcessBatchFunc func(context.Context, *Batch) error

ProcessBatchFunc is a function type that implements BatchProcessor.

func (ProcessBatchFunc) ProcessBatch

func (f ProcessBatchFunc) ProcessBatch(ctx context.Context, b *Batch) error

ProcessBatch calls f(ctx, b)

type ProcessThread

type ProcessThread struct {
	ID   int
	Name string
}

ProcessThread represents the thread information.

type Processor

type Processor struct {
	Name  string
	Event string
}

Processor identifies an event type, and is used for routing events to the appropriate data stream or index.

TODO(axw) this should be replaced with ECS event categorisation fields.

type Runtime

type Runtime struct {
	Name    string
	Version string
}

Runtime has an optional version and name

type Service

type Service struct {
	Name        string
	Version     string
	Environment string
	Language    Language
	Runtime     Runtime
	Framework   Framework
	Node        ServiceNode

	Origin *ServiceOrigin
	Target *ServiceTarget
}

Service bundles together information related to the monitored service and the agent used for monitoring

func (*Service) Fields

func (s *Service) Fields() map[string]any

Fields transforms a service instance into a map[string]any

type ServiceNode

type ServiceNode struct {
	Name string
}

type ServiceOrigin

type ServiceOrigin struct {
	ID      string
	Name    string
	Version string
}

ServiceOrigin holds information about the service that originated a transaction.

type ServiceTarget

type ServiceTarget struct {
	Name string
	Type string
}

ServiceTarget holds information about the target service in case of an outgoing event w.r.t. the instrumented service

type Session

type Session struct {
	// ID holds a session ID for grouping a set of related transactions.
	ID string

	// Sequence holds an optional sequence number for a transaction
	// within a session. Sequence is ignored if it is zero or if
	// ID is empty.
	Sequence int
}

Session holds information about a group of related transactions, such as a sequence of web interactions.

type Source

type Source struct {
	// Domain holds the client's domain (FQDN).
	Domain string

	// IP holds the client's IP address.
	IP netip.Addr

	// Port holds the client's IP port.
	Port int

	// NAT holds the translated source based NAT sessions.
	NAT *NAT
}

Source holds information about the source of a network exchange.

type Span

type Span struct {
	ID string

	// Name holds the span name: "SELECT FROM table_name", etc.
	Name string

	// Type holds the span type: "external", "db", etc.
	Type string

	// Kind holds the span kind: "CLIENT", "SERVER", "PRODUCER", "CONSUMER" and "INTERNAL".
	Kind string

	// Subtype holds the span subtype: "http", "sql", etc.
	Subtype string

	// Action holds the span action: "query", "execute", etc.
	Action string

	// SelfTime holds the aggregated span durations, for breakdown metrics.
	SelfTime AggregatedDuration

	Message    *Message
	Stacktrace Stacktrace
	Sync       *bool
	Links      []SpanLink

	DB                 *DB
	DestinationService *DestinationService
	Composite          *Composite

	// RepresentativeCount holds the approximate number of spans that
	// this span represents for aggregation. This will only be set when
	// the sampling rate is known, and is used for scaling metrics.
	RepresentativeCount float64
}

type SpanCount

type SpanCount struct {
	Dropped *int
	Started *int
}
type SpanLink struct {
	// Span holds information about the linked span event.
	Span Span

	// Trace holds information about the trace of the linked span event.
	Trace Trace
}

SpanLink represents a link between two span events, possibly (but not necessarily) in different traces.

type Stacktrace

type Stacktrace []*StacktraceFrame

type StacktraceFrame

type StacktraceFrame struct {
	AbsPath      string
	Filename     string
	Classname    string
	Lineno       *int
	Colno        *int
	ContextLine  string
	Module       string
	Function     string
	LibraryFrame bool
	Vars         map[string]any
	PreContext   []string
	PostContext  []string

	ExcludeFromGrouping bool

	SourcemapUpdated bool
	SourcemapError   string
	Original         Original
}

type SummaryMetric

type SummaryMetric struct {
	// Count holds the number of aggregated measurements.
	Count int64

	// Sum holds the sum of aggregated measurements.
	Sum float64
}

SummaryMetric holds summary metrics (count and sum).

type Trace

type Trace struct {
	// ID holds a unique identifier of the trace.
	ID string
}

Trace holds information about a distributed trace.

type Transaction

type Transaction struct {
	ID string

	// Name holds the transaction name: "GET /foo", etc.
	Name string

	// Type holds the transaction type: "request", "message", etc.
	Type string

	// Result holds the transaction result: "HTTP 2xx", "OK", "Error", etc.
	Result string

	// Sampled holds the transaction's sampling decision.
	//
	// If Sampled is false, then it will be omitted from the output event.
	Sampled bool

	// DurationHistogram holds a transaction duration histogram,
	// with bucket values measured in microseconds, for transaction
	// duration metrics.
	DurationHistogram Histogram

	// DurationSummary holds an aggregated transaction duration summary,
	// for service metrics. The DurationSummary.Sum field has microsecond
	// resolution.
	//
	// NOTE(axw) this is used only for service metrics, which are in technical
	// preview. Do not use this field without discussion, as the field mapping
	// is subject to removal.
	DurationSummary SummaryMetric

	// SuccessCount holds an aggregated count of transactions with different
	// outcomes. A "failure" adds to the Count. A "success" adds to both the
	// Count and the Sum. An "unknown" has no effect. If Count is zero, it
	// will be omitted from the output event.
	SuccessCount SummaryMetric

	Marks          TransactionMarks
	Message        *Message
	SpanCount      SpanCount
	Custom         map[string]any
	UserExperience *UserExperience

	// DroppedSpanStats holds a list of the spans that were dropped by an
	// agent; not indexed.
	DroppedSpansStats []DroppedSpanStats

	// RepresentativeCount holds the approximate number of
	// transactions that this transaction represents for aggregation.
	// This is used for scaling metrics.
	RepresentativeCount float64

	// Root indicates whether or not the transaction is the trace root.
	//
	// If Root is false, it will be omitted from the output event.
	Root bool
}

Transaction holds values for transaction.* fields. This may be used in transaction, span, and error events (i.e. transaction.id), as well as internal metrics such as breakdowns (i.e. including transaction.name).

type TransactionMark

type TransactionMark map[string]float64

type TransactionMarks

type TransactionMarks map[string]TransactionMark

type URL

type URL struct {
	Original string
	Scheme   string
	Full     string
	Domain   string
	Port     int
	Path     string
	Query    string
	Fragment string
}

URL describes an URL and its components

func ParseURL

func ParseURL(original, defaultHostname, defaultScheme string) URL

type User

type User struct {
	Domain string
	ID     string
	Email  string
	Name   string
}

type UserAgent

type UserAgent struct {
	// Original holds the original, full, User-Agent string.
	Original string

	// Name holds the user_agent.name value from the parsed User-Agent string.
	// If Original is set, then this should typically not be set, as the full
	// User-Agent string can be parsed by ingest node.
	Name string
}

type UserExperience

type UserExperience struct {
	// CumulativeLayoutShift holds the Cumulative Layout Shift (CLS) metric value,
	// or a negative value if CLS is unknown. See https://web.dev/cls/
	CumulativeLayoutShift float64

	// FirstInputDelay holds the First Input Delay (FID) metric value,
	// or a negative value if FID is unknown. See https://web.dev/fid/
	FirstInputDelay float64

	// TotalBlockingTime holds the Total Blocking Time (TBT) metric value,
	// or a negative value if TBT is unknown. See https://web.dev/tbt/
	TotalBlockingTime float64

	// Longtask holds longtask metrics. If Longtask.Count is negative,
	// then Longtask is considered unset. See https://www.w3.org/TR/longtasks/
	Longtask LongtaskMetrics
}

UserExperience holds real user (browser) experience metrics.

func (*UserExperience) Fields

func (u *UserExperience) Fields() map[string]any

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL