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,
        },
    )

    // 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,
        },
    )

    // SyncProxyRulesLastQueuedTimestamp is the last time a proxy sync was
    // requested. If this is much larger than
    // kubeproxy_sync_proxy_rules_last_timestamp_seconds, then something is hung.
    SyncProxyRulesLastQueuedTimestamp = metrics.NewGauge(
        &metrics.GaugeOpts{
            Subsystem:      kubeProxySubsystem,
            Name:           "sync_proxy_rules_last_queued_timestamp_seconds",
            Help:           "The last time a sync of proxy rules was queued",
            StabilityLevel: metrics.ALPHA,
        },
    )
)

func RegisterMetrics Uses

func RegisterMetrics()

RegisterMetrics registers kube-proxy metrics.

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 37 packages. Updated 2020-04-26. Refresh now. Tools for package owners.