// PrepareCollection applies options defaults and fallback values, then filters entries by graphs titles and state. func (library *Library) PrepareCollection(collection *Collection, filter string) *Collection { collectionTemp := &Collection{} *collectionTemp = *collection collectionTemp.Entries = nil refreshInterval, _ := config.GetInt(collectionTemp.Options, "refresh_interval", false) for _, entry := range collection.Entries { item, err := library.GetItem(entry.ID, LibraryItemGraph) if err != nil { continue } graph := item.(*Graph) // Initialize options map if needed, then set defaults if entry.Options == nil { entry.Options = make(map[string]interface{}) entry.Options["enabled"] = true } // Check for linked graph if graph.Link != "" { entry.Options["linked"] = true } // Retrieve missing title from graph if none provided if title, ok := entry.Options["title"]; !ok || title == nil { if graph.Title != "" { entry.Options["title"] = graph.Title } else { entry.Options["title"] = graph.Name } } // Get global refresh interval if none provided if refreshInterval > 0 { if _, err := config.GetInt(entry.Options, "refresh_interval", true); err != nil { entry.Options["refresh_interval"] = refreshInterval } } if enabled, err := config.GetBool(entry.Options, "enabled", false); err != nil || !enabled { continue } else if filter != "" { if title, err := config.GetString(entry.Options, "title", false); err != nil || !strings.Contains(strings.ToLower(title), strings.ToLower(filter)) { continue } } collectionTemp.Entries = append(collectionTemp.Entries, entry) } return collectionTemp }
func init() { Connectors["facette"] = func(name string, settings map[string]interface{}) (Connector, error) { var err error c := &FacetteConnector{name: name} if c.upstream, err = config.GetString(settings, "upstream", true); err != nil { return nil, err } if c.timeout, err = config.GetInt(settings, "timeout", false); err != nil { return nil, err } if c.timeout <= 0 { c.timeout = facetteDefaultTimeout } if c.insecureTLS, err = config.GetBool(settings, "allow_insecure_tls", false); err != nil { return nil, err } if c.serverID, err = config.GetString(settings, "_id", true); err != nil { return nil, err } return c, nil } }
func init() { Connectors["graphite"] = func(name string, settings map[string]interface{}) (Connector, error) { var ( pattern string err error ) c := &GraphiteConnector{ name: name, series: make(map[string]map[string]string), } if c.url, err = config.GetString(settings, "url", true); err != nil { return nil, err } if c.timeout, err = config.GetInt(settings, "timeout", false); err != nil { return nil, err } if c.timeout <= 0 { c.timeout = graphiteDefaultTimeout } if c.insecureTLS, err = config.GetBool(settings, "allow_insecure_tls", false); err != nil { return nil, err } if pattern, err = config.GetString(settings, "pattern", true); err != nil { return nil, err } if c.re, err = compilePattern(pattern); err != nil { return nil, fmt.Errorf("unable to compile regexp pattern: %s", err) } return c, nil } }
func init() { Connectors["kairosdb"] = func(name string, settings map[string]interface{}) (Connector, error) { var ( aggregators interface{} err error ) c := &KairosdbConnector{ name: name, timeout: kairosdbDefaultTimeout, series: make(map[string]map[string]kairosdbSeriesEntry), } if c.url, err = config.GetString(settings, "url", true); err != nil { return nil, err } if c.timeout, err = config.GetInt(settings, "timeout", false); err != nil { return nil, err } if c.timeout <= 0 { c.timeout = kairosdbDefaultTimeout } if c.insecureTLS, err = config.GetBool(settings, "allow_insecure_tls", false); err != nil { return nil, err } if c.sourceTags, err = config.GetStringSlice(settings, "source_tags", false); err != nil { return nil, err } if c.startAbsolute, err = config.GetInt(settings, "start_absolute", false); err != nil { return nil, err } if c.endAbsolute, err = config.GetInt(settings, "end_absolute", false); err != nil { return nil, err } if c.startRelative, err = config.GetJsonObj(settings, "start_relative", false); err != nil { return nil, err } if c.endRelative, err = config.GetJsonObj(settings, "end_relative", false); err != nil { return nil, err } if c.defaultAggregator, err = config.GetJsonObj(settings, "default_aggregator", false); err != nil { return nil, err } if aggregators, err = config.GetJsonArray(settings, "aggregators", false); err != nil { return nil, err } c.aggregators = compileAggregatorPatterns(aggregators, c.name) if c.startAbsolute > 0 && c.startRelative != nil { return nil, fmt.Errorf("kairosdb[%s]: start_absolute/start_relative are mutually exclusive", c.name) } if c.endAbsolute > 0 && c.endRelative != nil { return nil, fmt.Errorf("kairosdb[%s]: end_absolute/end_relative are mutually exclusive", c.name) } // Enforce startRelative defaults if c.startAbsolute <= 0 && c.startRelative == nil { c.startRelative = map[string]interface{}{"value": 3, "unit": "months"} } // Enforce sourceTags defaults if c.sourceTags == nil { c.sourceTags = []string{"host", "server", "device"} } version, version_array, err := kairosdbGetVersion(c) if err != nil { return nil, fmt.Errorf("kairosdb[%s]: unable to get KairosDB version: %s", c.name, err) } if version_array[0] < 1 { if version_array[1] <= 9 { if version_array[1] < 9 || (version_array[1] == 9 && version_array[2] < 4) { return nil, fmt.Errorf( "kairosdb[%s]: only KairosDB version 0.9.4 and greater are supported (%s detected)", c.name, version, ) } } } return c, nil } }
func makePlotsResponse(plotSeries map[string][]plot.Series, plotReq *PlotRequest, graph *library.Graph) (*PlotResponse, error) { response := &PlotResponse{ ID: graph.ID, Start: plotReq.startTime.Format(time.RFC3339), End: plotReq.endTime.Format(time.RFC3339), Name: graph.Name, Description: graph.Description, Title: graph.Title, Type: graph.Type, StackMode: graph.StackMode, UnitType: graph.UnitType, UnitLegend: graph.UnitLegend, Modified: graph.Modified, } for _, groupItem := range graph.Groups { var ( groupConsolidate int groupSeries []plot.Series err error ) seriesOptions := make(map[string]map[string]interface{}) for _, seriesItem := range groupItem.Series { if _, ok := plotSeries[seriesItem.Name]; !ok { return nil, fmt.Errorf("unable to find plots for `%s' series", seriesItem.Name) } for _, plotItem := range plotSeries[seriesItem.Name] { var optionKey string // Apply series scale if any if scale, _ := config.GetFloat(seriesItem.Options, "scale", false); scale != 0 { plotItem.Scale(plot.Value(scale)) } // Merge options from group and series if groupItem.Type == plot.OperTypeAverage || groupItem.Type == plot.OperTypeSum { optionKey = groupItem.Name } else { optionKey = seriesItem.Name } seriesOptions[optionKey] = make(map[string]interface{}) for key, value := range groupItem.Options { seriesOptions[optionKey][key] = value } if groupItem.Type != plot.OperTypeAverage && groupItem.Type != plot.OperTypeSum { for key, value := range seriesItem.Options { seriesOptions[optionKey][key] = value } } groupSeries = append(groupSeries, plotItem) } } if len(groupSeries) == 0 { continue } // Normalize all series plots on the same time step groupConsolidate, err = config.GetInt(groupItem.Options, "consolidate", true) if err != nil { groupConsolidate = plot.ConsolidateAverage } groupSeries, err = plot.Normalize( groupSeries, plotReq.startTime, plotReq.endTime, plotReq.Sample, groupConsolidate, ) if err != nil { return nil, fmt.Errorf("unable to consolidate series: %s", err) } // Perform requested series operations if groupItem.Type == plot.OperTypeAverage || groupItem.Type == plot.OperTypeSum { var ( operSeries plot.Series err error ) if groupItem.Type == plot.OperTypeAverage { operSeries, err = plot.AverageSeries(groupSeries) if err != nil { return nil, fmt.Errorf("unable to average series: %s", err) } } else { operSeries, err = plot.SumSeries(groupSeries) if err != nil { return nil, fmt.Errorf("unable to sum series: %s", err) } } operSeries.Name = groupItem.Name groupSeries = []plot.Series{operSeries} } // Apply group scale if any if scale, _ := config.GetFloat(groupItem.Options, "scale", false); scale != 0 { for _, seriesItem := range groupSeries { seriesItem.Scale(plot.Value(scale)) } } for _, seriesItem := range groupSeries { // Summarize each series (compute min/max/avg/last values) seriesItem.Summarize(plotReq.Percentiles) response.Series = append(response.Series, &SeriesResponse{ Name: seriesItem.Name, StackID: groupItem.StackID, Plots: seriesItem.Plots, Summary: seriesItem.Summary, Options: seriesOptions[seriesItem.Name], }) } } return response, nil }