| // Copyright 2014 Google Inc. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package driver |
| |
| import ( |
| "fmt" |
| "regexp" |
| "strconv" |
| "strings" |
| |
| "github.com/google/pprof/internal/measurement" |
| "github.com/google/pprof/internal/plugin" |
| "github.com/google/pprof/profile" |
| ) |
| |
| var tagFilterRangeRx = regexp.MustCompile("([+-]?[[:digit:]]+)([[:alpha:]]+)?") |
| |
| // applyFocus filters samples based on the focus/ignore options |
| func applyFocus(prof *profile.Profile, numLabelUnits map[string]string, cfg config, ui plugin.UI) error { |
| focus, err := compileRegexOption("focus", cfg.Focus, nil) |
| ignore, err := compileRegexOption("ignore", cfg.Ignore, err) |
| hide, err := compileRegexOption("hide", cfg.Hide, err) |
| show, err := compileRegexOption("show", cfg.Show, err) |
| showfrom, err := compileRegexOption("show_from", cfg.ShowFrom, err) |
| tagfocus, err := compileTagFilter("tagfocus", cfg.TagFocus, numLabelUnits, ui, err) |
| tagignore, err := compileTagFilter("tagignore", cfg.TagIgnore, numLabelUnits, ui, err) |
| prunefrom, err := compileRegexOption("prune_from", cfg.PruneFrom, err) |
| if err != nil { |
| return err |
| } |
| |
| fm, im, hm, hnm := prof.FilterSamplesByName(focus, ignore, hide, show) |
| warnNoMatches(focus == nil || fm, "Focus", ui) |
| warnNoMatches(ignore == nil || im, "Ignore", ui) |
| warnNoMatches(hide == nil || hm, "Hide", ui) |
| warnNoMatches(show == nil || hnm, "Show", ui) |
| |
| sfm := prof.ShowFrom(showfrom) |
| warnNoMatches(showfrom == nil || sfm, "ShowFrom", ui) |
| |
| tfm, tim := prof.FilterSamplesByTag(tagfocus, tagignore) |
| warnNoMatches(tagfocus == nil || tfm, "TagFocus", ui) |
| warnNoMatches(tagignore == nil || tim, "TagIgnore", ui) |
| |
| tagshow, err := compileRegexOption("tagshow", cfg.TagShow, err) |
| taghide, err := compileRegexOption("taghide", cfg.TagHide, err) |
| tns, tnh := prof.FilterTagsByName(tagshow, taghide) |
| warnNoMatches(tagshow == nil || tns, "TagShow", ui) |
| warnNoMatches(taghide == nil || tnh, "TagHide", ui) |
| |
| if prunefrom != nil { |
| prof.PruneFrom(prunefrom) |
| } |
| return err |
| } |
| |
| func compileRegexOption(name, value string, err error) (*regexp.Regexp, error) { |
| if value == "" || err != nil { |
| return nil, err |
| } |
| rx, err := regexp.Compile(value) |
| if err != nil { |
| return nil, fmt.Errorf("parsing %s regexp: %v", name, err) |
| } |
| return rx, nil |
| } |
| |
| func compileTagFilter(name, value string, numLabelUnits map[string]string, ui plugin.UI, err error) (func(*profile.Sample) bool, error) { |
| if value == "" || err != nil { |
| return nil, err |
| } |
| |
| tagValuePair := strings.SplitN(value, "=", 2) |
| var wantKey string |
| if len(tagValuePair) == 2 { |
| wantKey = tagValuePair[0] |
| value = tagValuePair[1] |
| } |
| |
| if numFilter := parseTagFilterRange(value); numFilter != nil { |
| ui.PrintErr(name, ":Interpreted '", value, "' as range, not regexp") |
| labelFilter := func(vals []int64, unit string) bool { |
| for _, val := range vals { |
| if numFilter(val, unit) { |
| return true |
| } |
| } |
| return false |
| } |
| numLabelUnit := func(key string) string { |
| return numLabelUnits[key] |
| } |
| if wantKey == "" { |
| return func(s *profile.Sample) bool { |
| for key, vals := range s.NumLabel { |
| if labelFilter(vals, numLabelUnit(key)) { |
| return true |
| } |
| } |
| return false |
| }, nil |
| } |
| return func(s *profile.Sample) bool { |
| if vals, ok := s.NumLabel[wantKey]; ok { |
| return labelFilter(vals, numLabelUnit(wantKey)) |
| } |
| return false |
| }, nil |
| } |
| |
| var rfx []*regexp.Regexp |
| for _, tagf := range strings.Split(value, ",") { |
| fx, err := regexp.Compile(tagf) |
| if err != nil { |
| return nil, fmt.Errorf("parsing %s regexp: %v", name, err) |
| } |
| rfx = append(rfx, fx) |
| } |
| if wantKey == "" { |
| return func(s *profile.Sample) bool { |
| matchedrx: |
| for _, rx := range rfx { |
| for key, vals := range s.Label { |
| for _, val := range vals { |
| // TODO: Match against val, not key:val in future |
| if rx.MatchString(key + ":" + val) { |
| continue matchedrx |
| } |
| } |
| } |
| return false |
| } |
| return true |
| }, nil |
| } |
| return func(s *profile.Sample) bool { |
| if vals, ok := s.Label[wantKey]; ok { |
| for _, rx := range rfx { |
| for _, val := range vals { |
| if rx.MatchString(val) { |
| return true |
| } |
| } |
| } |
| } |
| return false |
| }, nil |
| } |
| |
| // parseTagFilterRange returns a function to checks if a value is |
| // contained on the range described by a string. It can recognize |
| // strings of the form: |
| // "32kb" -- matches values == 32kb |
| // ":64kb" -- matches values <= 64kb |
| // "4mb:" -- matches values >= 4mb |
| // "12kb:64mb" -- matches values between 12kb and 64mb (both included). |
| func parseTagFilterRange(filter string) func(int64, string) bool { |
| ranges := tagFilterRangeRx.FindAllStringSubmatch(filter, 2) |
| if len(ranges) == 0 { |
| return nil // No ranges were identified |
| } |
| v, err := strconv.ParseInt(ranges[0][1], 10, 64) |
| if err != nil { |
| panic(fmt.Errorf("failed to parse int %s: %v", ranges[0][1], err)) |
| } |
| scaledValue, unit := measurement.Scale(v, ranges[0][2], ranges[0][2]) |
| if len(ranges) == 1 { |
| switch match := ranges[0][0]; filter { |
| case match: |
| return func(v int64, u string) bool { |
| sv, su := measurement.Scale(v, u, unit) |
| return su == unit && sv == scaledValue |
| } |
| case match + ":": |
| return func(v int64, u string) bool { |
| sv, su := measurement.Scale(v, u, unit) |
| return su == unit && sv >= scaledValue |
| } |
| case ":" + match: |
| return func(v int64, u string) bool { |
| sv, su := measurement.Scale(v, u, unit) |
| return su == unit && sv <= scaledValue |
| } |
| } |
| return nil |
| } |
| if filter != ranges[0][0]+":"+ranges[1][0] { |
| return nil |
| } |
| if v, err = strconv.ParseInt(ranges[1][1], 10, 64); err != nil { |
| panic(fmt.Errorf("failed to parse int %s: %v", ranges[1][1], err)) |
| } |
| scaledValue2, unit2 := measurement.Scale(v, ranges[1][2], unit) |
| if unit != unit2 { |
| return nil |
| } |
| return func(v int64, u string) bool { |
| sv, su := measurement.Scale(v, u, unit) |
| return su == unit && sv >= scaledValue && sv <= scaledValue2 |
| } |
| } |
| |
| func warnNoMatches(match bool, option string, ui plugin.UI) { |
| if !match { |
| ui.PrintErr(option + " expression matched no samples") |
| } |
| } |