Your advanced code editor is loading.

Please wait a moment.

#editor-loading { display: none; }

// Copyright (c) The Thanos Authors. // Licensed under the Apache License 2.0.

package ui

import ( “fmt” “html/template” “math” “regexp” “time”

"github.com/go-kit/log" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/common/route" "github.com/prometheus/prometheus/rules"

"github.com/thanos-io/thanos/pkg/component" extpromhttp "github.com/thanos-io/thanos/pkg/extprom/http" thanosrules "github.com/thanos-io/thanos/pkg/rules"

)

type Rule struct { *BaseUI

externalPrefix, prefixHeader string

ruleManager *thanosrules.Manager queryURL string reg prometheus.Registerer

}

func NewRuleUI(logger log.Logger, reg prometheus.Registerer, ruleManager *thanosrules.Manager, queryURL, externalPrefix, prefixHeader string) *Rule { tmplVariables := map[string]string{ “Component”: component.Rule.String(), “queryURL”: queryURL, }

tmplFuncs := ruleTmplFuncs(queryURL)
          
          return &Rule{
          BaseUI:         NewBaseUI(logger, tmplFuncs, tmplVariables, externalPrefix, prefixHeader, component.Rule),
          externalPrefix: externalPrefix,
          prefixHeader:   prefixHeader,
          ruleManager:    ruleManager,
          queryURL:       queryURL,
          reg:            reg,
          }

}

func ruleTmplFuncs(queryURL string) template.FuncMap { return template.FuncMap{ “since”: func(t time.Time) time.Duration { return time.Since(t) / time.Millisecond * time.Millisecond }, “alertStateToClass”: func(as rules.AlertState) string { switch as { case rules.StateInactive: return “success” case rules.StatePending: return “warning” case rules.StateFiring: return “danger” default: panic(“unknown alert state”) } }, “ruleHealthToClass”: func(rh rules.RuleHealth) string { switch rh { case rules.HealthUnknown: return “warning” case rules.HealthGood: return “success” default: return “danger” } }, “queryURL”: func() string { return queryURL }, “reReplaceAll”: func(pattern, repl, text string) string { re := regexp.MustCompile(pattern) return re.ReplaceAllString(text, repl) }, “humanizeDuration”: func(v float64) string { if math.IsNaN(v) || math.IsInf(v, 0) { return fmt.Sprintf(“%.4g”, v) } if v == 0 { return fmt.Sprintf(“%.4gs”, v) } if math.Abs(v) >= 1 { sign := “” if v < 0 { sign = “-” v = -v } seconds := int64(v) % 60 minutes := (int64(v) / 60) % 60 hours := (int64(v) / 60 / 60) % 24 days := (int64(v) / 60 / 60 / 24) // For days to minutes, we display seconds as an integer. if days != 0 { return fmt.Sprintf(“%s%dd %dh %dm %ds”, sign, days, hours, minutes, seconds) } if hours != 0 { return fmt.Sprintf(“%s%dh %dm %ds”, sign, hours, minutes, seconds) } if minutes != 0 { return fmt.Sprintf(“%s%dm %ds”, sign, minutes, seconds) } // For seconds, we display 4 significant digits. return fmt.Sprintf(“%s%.4gs”, sign, v) } prefix := “” for _, p := range []string{“m”, “u”, “n”, “p”, “f”, “a”, “z”, “y”} { if math.Abs(v) >= 1 { break } prefix = p v *= 1000 } return fmt.Sprintf(“%.4g%ss”, v, prefix) }, } }

func (ru *Rule) Register(r *route.Router, ins extpromhttp.InstrumentationMiddleware) { registerReactApp(r, ins, ru.BaseUI) }

Explanation

The code defines a Rule struct responsible for handling rule-related UI elements in a Thanos application. It leverages the BaseUI struct, which likely provides basic UI functionalities and components.

Breakdown:

Rule Struct:
Holds a reference to a BaseUI instance for common UI operations.
externalPrefix and prefixHeader are likely used for routing and header manipulation.
ruleManager points to a thanosrules.Manager instance for managing rules and alerts.
queryURL stores the base URL for querying metrics.
reg is a Prometheus registerer for metrics registration.
NewRuleUI Constructor:
Initializes a Rule instance with provided logger, Prometheus registerer, rule manager, query URL, and routing prefixes.
Defines template variables specific to the rules UI (e.g., Component, queryURL).
Creates a template function map (ruleTmplFuncs) for handling specific UI tasks.
Sets up the BaseUI with the provided configuration and component type.
ruleTmplFuncs Function:
Provides a set of template functions used for formatting and manipulating data within UI templates:
since: Calculates the time difference between a given timestamp and the current time.
alertStateToClass: Maps an alert state (e.g., StateInactive, StateFiring) to a corresponding CSS class (e.g., “success”, “danger”).
ruleHealthToClass: Maps a rule health status (e.g., HealthGood, HealthUnknown) to a CSS class.
queryURL: Returns the provided query URL.
reReplaceAll: Performs regular expression replacement in a string.
humanizeDuration: Formats a duration value in a human-readable format.
Register Method:
Registers the rule UI under the given router r with instrumentation middleware ins.
Calls registerReactApp (not defined here, likely responsible for setting up a React-based application), passing the router, instrumentation, and the BaseUI instance.

Key Points:

This code implements the rule UI component within a Thanos application, relying on Prometheus rule management and UI functionalities provided by BaseUI.
It leverages template functions for formatting data, mapping alert states and rule health to CSS classes, and displaying durations in a user-friendly manner.
The Register method integrates the rule UI into the application’s routing system, potentially utilizing a React framework for the frontend.

Your advanced code editor is loading.

Please wait a moment.

Explanation

Graph

Symbols

We couldn't identify any entrypoints. If you believe this to be incorrect then please contact support.