kubernetes: k8s.io/kubernetes/pkg/proxy/metrics Index | Files

package metrics

import "k8s.io/kubernetes/pkg/proxy/metrics"

Index

Package Files

metrics.go

Variables

var (
    // SyncProxyRulesLatency is the latency of one round of kube-proxy syncing proxy rules.
    SyncProxyRulesLatency = metrics.NewHistogram(
        &metrics.HistogramOpts{
            Subsystem:      kubeProxySubsystem,
            Name:           "sync_proxy_rules_duration_seconds",
            Help:           "SyncProxyRules latency in seconds",
            Buckets:        metrics.ExponentialBuckets(0.001, 2, 15),
            StabilityLevel: metrics.ALPHA,
        },
    )

    // DeprecatedSyncProxyRulesLatency is the latency of one round of kube-proxy syncing proxy rules.
    DeprecatedSyncProxyRulesLatency = metrics.NewHistogram(
        &metrics.HistogramOpts{
            Subsystem:      kubeProxySubsystem,
            Name:           "sync_proxy_rules_latency_microseconds",
            Help:           "(Deprecated) SyncProxyRules latency in microseconds",
            Buckets:        metrics.ExponentialBuckets(1000, 2, 15),
            StabilityLevel: metrics.ALPHA,
        },
    )

    // SyncProxyRulesLastTimestamp is the timestamp proxy rules were last
    // successfully synced.
    SyncProxyRulesLastTimestamp = metrics.NewGauge(
        &metrics.GaugeOpts{
            Subsystem:      kubeProxySubsystem,
            Name:           "sync_proxy_rules_last_timestamp_seconds",
            Help:           "The last time proxy rules were successfully synced",
            StabilityLevel: metrics.ALPHA,
        },
    )

    // NetworkProgrammingLatency is defined as the time it took to program the network - from the time
    // the service or pod has changed to the time the change was propagated and the proper kube-proxy
    // rules were synced. Exported for each endpoints object that were part of the rules sync.
    // See https://github.com/kubernetes/community/blob/master/sig-scalability/slos/network_programming_latency.md
    // Note that the metrics is partially based on the time exported by the endpoints controller on
    // the master machine. The measurement may be inaccurate if there is a clock drift between the
    // node and master machine.
    NetworkProgrammingLatency = metrics.NewHistogram(
        &metrics.HistogramOpts{
            Subsystem: kubeProxySubsystem,
            Name:      "network_programming_duration_seconds",
            Help:      "In Cluster Network Programming Latency in seconds",
            Buckets: merge(
                metrics.LinearBuckets(0.25, 0.25, 2),
                metrics.LinearBuckets(1, 1, 59),
                metrics.LinearBuckets(60, 5, 12),
                metrics.LinearBuckets(120, 30, 7),
            ),
            StabilityLevel: metrics.ALPHA,
        },
    )

    // EndpointChangesPending is the number of pending endpoint changes that
    // have not yet been synced to the proxy.
    EndpointChangesPending = metrics.NewGauge(
        &metrics.GaugeOpts{
            Subsystem:      kubeProxySubsystem,
            Name:           "sync_proxy_rules_endpoint_changes_pending",
            Help:           "Pending proxy rules Endpoint changes",
            StabilityLevel: metrics.ALPHA,
        },
    )

    // EndpointChangesTotal is the number of endpoint changes that the proxy
    // has seen.
    EndpointChangesTotal = metrics.NewCounter(
        &metrics.CounterOpts{
            Subsystem:      kubeProxySubsystem,
            Name:           "sync_proxy_rules_endpoint_changes_total",
            Help:           "Cumulative proxy rules Endpoint changes",
            StabilityLevel: metrics.ALPHA,
        },
    )

    // ServiceChangesPending is the number of pending service changes that
    // have not yet been synced to the proxy.
    ServiceChangesPending = metrics.NewGauge(
        &metrics.GaugeOpts{
            Subsystem:      kubeProxySubsystem,
            Name:           "sync_proxy_rules_service_changes_pending",
            Help:           "Pending proxy rules Service changes",
            StabilityLevel: metrics.ALPHA,
        },
    )

    // ServiceChangesTotal is the number of service changes that the proxy has
    // seen.
    ServiceChangesTotal = metrics.NewCounter(
        &metrics.CounterOpts{
            Subsystem:      kubeProxySubsystem,
            Name:           "sync_proxy_rules_service_changes_total",
            Help:           "Cumulative proxy rules Service changes",
            StabilityLevel: metrics.ALPHA,
        },
    )

    // IptablesRestoreFailuresTotal is the number of iptables restore failures that the proxy has
    // seen.
    IptablesRestoreFailuresTotal = metrics.NewCounter(
        &metrics.CounterOpts{
            Subsystem:      kubeProxySubsystem,
            Name:           "sync_proxy_rules_iptables_restore_failures_total",
            Help:           "Cumulative proxy iptables restore failures",
            StabilityLevel: metrics.ALPHA,
        },
    )
)

func RegisterMetrics Uses

func RegisterMetrics()

RegisterMetrics registers kube-proxy metrics.

func SinceInMicroseconds Uses

func SinceInMicroseconds(start time.Time) float64

SinceInMicroseconds gets the time since the specified start in microseconds.

func SinceInSeconds Uses

func SinceInSeconds(start time.Time) float64

SinceInSeconds gets the time since the specified start in seconds.

Package metrics imports 4 packages (graph) and is imported by 33 packages. Updated 2019-09-20. Refresh now. Tools for package owners.