def extractPathExpressions(requestContext, targets): # Returns a list of unique pathExpressions found in the targets list pathExpressions = set() def extractPathExpression(requestContext, tokens, replacements=None): if tokens.template: arglist = dict() if tokens.template.kwargs: arglist.update( dict([(kwarg.argname, evaluateScalarTokens(kwarg.args[0])) for kwarg in tokens.template.kwargs])) if tokens.template.args: arglist.update( dict([(str(i + 1), evaluateScalarTokens(arg)) for i, arg in enumerate(tokens.template.args)])) if 'template' in requestContext: arglist.update(requestContext['template']) extractPathExpression(requestContext, tokens.template, arglist) elif tokens.expression: extractPathExpression(requestContext, tokens.expression, replacements) if tokens.expression.pipedCalls: for token in tokens.expression.pipedCalls: extractPathExpression(requestContext, token, replacements) elif tokens.pathExpression: expression = tokens.pathExpression if replacements: for name in replacements: if expression != '$' + name: expression = expression.replace( '$' + name, str(replacements[name])) pathExpressions.add(expression) elif tokens.call: # if we're prefetching seriesByTag, look up the matching series and prefetch those if tokens.call.funcname == 'seriesByTag': if STORE.tagdb: for series in STORE.tagdb.find_series( tuple([ t.string[1:-1] for t in tokens.call.args if t.string ]), requestContext=requestContext, ): pathExpressions.add(series) else: for a in tokens.call.args: extractPathExpression(requestContext, a, replacements) for target in targets: if not target: continue if isinstance(target, six.string_types): if not target.strip(): continue target = grammar.parseString(target) extractPathExpression(requestContext, target) return list(pathExpressions)
def _tag_patterns(self, patterns, requestContext): tag_patterns = [] pattern_aliases = defaultdict(list) for pattern in patterns: # if pattern isn't a seriesByTag call, just add it to the list if not pattern.startswith('seriesByTag('): tag_patterns.append(pattern) continue # perform the tagdb lookup exprs = tuple([ t.string[1:-1] for t in grammar.parseString(pattern).expression.call.args if t.string ]) taggedSeries = self.tagdb.find_series(exprs, requestContext=requestContext) if not taggedSeries: continue # add to translation table for path matching for series in taggedSeries: pattern_aliases[series].append(pattern) # add to list of resolved patterns tag_patterns.extend(taggedSeries) return sorted(set(tag_patterns)), pattern_aliases
def _tag_patterns(self, patterns, requestContext): tag_patterns = [] pattern_aliases = defaultdict(list) for pattern in patterns: # if pattern isn't a seriesByTag call, just add it to the list if not pattern.startswith('seriesByTag('): tag_patterns.append(pattern) continue # perform the tagdb lookup exprs = tuple([ t.string[1:-1] for t in grammar.parseString(pattern).expression.call.args if t.string ]) taggedSeries = self.tagdb.find_series( exprs, requestContext=requestContext) if not taggedSeries: continue # add to translation table for path matching for series in taggedSeries: pattern_aliases[series].append(pattern) # add to list of resolved patterns tag_patterns.extend(taggedSeries) return sorted(set(tag_patterns)), pattern_aliases
def evaluateTarget(requestContext, targets, noPrefetch=False): if not isinstance(targets, list): targets = [targets] if settings.REMOTE_PREFETCH_DATA and not requestContext.get( 'localOnly') and not noPrefetch: prefetchRemoteData(requestContext, targets) seriesList = [] for target in targets: if isinstance(target, basestring): if not target.strip(): continue target = grammar.parseString(target) result = evaluateTokens(requestContext, target) # we have to return a list of TimeSeries objects if isinstance(result, TimeSeries): seriesList.append(result) elif result: seriesList.extend(result) return seriesList
def extractPathExpressions(targets): # Returns a list of unique pathExpressions found in the targets list pathExpressions = set() def extractPathExpression(tokens): if tokens.expression: return extractPathExpression(tokens.expression) elif tokens.pathExpression: pathExpressions.add(tokens.pathExpression) elif tokens.call: # if we're prefetching seriesByTag, look up the matching series and prefetch those if tokens.call.funcname == 'seriesByTag': if STORE.tagdb: for series in STORE.tagdb.find_series([t.string[1:-1] for t in tokens.call.args if t.string]): pathExpressions.add(series) else: for a in tokens.call.args: extractPathExpression(a) for target in targets: tokens = grammar.parseString(target) extractPathExpression(tokens) return list(pathExpressions)
def extractPathExpressions(targets): # Returns a list of unique pathExpressions found in the targets list pathExpressions = set() def extractPathExpression(tokens): if tokens.expression: return extractPathExpression(tokens.expression) elif tokens.pathExpression: pathExpressions.add(tokens.pathExpression) elif tokens.call: # if we're prefetching seriesByTag, look up the matching series and prefetch those if tokens.call.funcname == 'seriesByTag': if STORE.tagdb: for series in STORE.tagdb.find_series( [t.string[1:-1] for t in tokens.call.args if t.string]): pathExpressions.add(series) else: for a in tokens.call.args: extractPathExpression(a) for target in targets: tokens = grammar.parseString(target) extractPathExpression(tokens) return list(pathExpressions)
def evaluateTarget(requestContext, targets): if not isinstance(targets, list): targets = [targets] pathExpressions = extractPathExpressions(requestContext, targets) prefetchData(requestContext, pathExpressions) seriesList = [] for target in targets: if not target: continue if isinstance(target, six.string_types): if not target.strip(): continue target = grammar.parseString(target) try: result = evaluateTokens(requestContext, target) except InputParameterError as e: e.setTargets(requestContext.get('targets', [])) e.setSourceIdHeaders(requestContext.get('sourceIdHeaders', {})) raise # we have to return a list of TimeSeries objects if isinstance(result, TimeSeries): seriesList.append(result) elif result: seriesList.extend(result) return seriesList
def evaluateTarget(requestContext, targets): if not isinstance(targets, list): targets = [targets] pathExpressions = extractPathExpressions(requestContext, targets) prefetchData(requestContext, pathExpressions) seriesList = [] for target in targets: if not target: continue if isinstance(target, six.string_types): if not target.strip(): continue target = grammar.parseString(target) result = evaluateTokens(requestContext, target) # we have to return a list of TimeSeries objects if isinstance(result, TimeSeries): seriesList.append(result) elif result: seriesList.extend(result) return seriesList
def find_metric_by_tags_many(self, patterns, cache): result = {} for pattern in patterns: args = grammar.parseString(pattern).expression.call.args exprs = [t.string[1:-1] for t in args if t.string] queries = [parse_tagspec(e) for e in exprs] result[pattern] = self.metric_index.match_by_tags(queries, cache) return result
def evaluateTarget(requestContext, target): tokens = grammar.parseString(target) result = evaluateTokens(requestContext, tokens) if type(result) is TimeSeries: return [result] #we have to return a list of TimeSeries objects else: return result
def evaluateTarget(target, timeInterval): tokens = grammar.parseString(target) result = evaluateTokens(tokens, timeInterval) if type(result) is TimeSeries: return [result] #we have to return a list of TimeSeries objects else: return result
def extractPathExpressions(requestContext, targets): # Returns a list of unique pathExpressions found in the targets list pathExpressions = set() def extractPathExpression(requestContext, tokens, replacements=None): if tokens.template: arglist = dict() if tokens.template.kwargs: arglist.update(dict([(kwarg.argname, evaluateScalarTokens(kwarg.args[0])) for kwarg in tokens.template.kwargs])) if tokens.template.args: arglist.update(dict([(str(i+1), evaluateScalarTokens(arg)) for i, arg in enumerate(tokens.template.args)])) if 'template' in requestContext: arglist.update(requestContext['template']) extractPathExpression(requestContext, tokens.template, arglist) elif tokens.expression: extractPathExpression(requestContext, tokens.expression, replacements) if tokens.expression.pipedCalls: for token in tokens.expression.pipedCalls: extractPathExpression(requestContext, token, replacements) elif tokens.pathExpression: expression = tokens.pathExpression if replacements: for name in replacements: if expression != '$'+name: expression = expression.replace('$'+name, str(replacements[name])) pathExpressions.add(expression) elif tokens.call: # if we're prefetching seriesByTag, pass the entire call back as a path expression if tokens.call.funcname == 'seriesByTag': pathExpressions.add(tokens.call.raw) else: for a in tokens.call.args: extractPathExpression(requestContext, a, replacements) for target in targets: if not target: continue if isinstance(target, six.string_types): if not target.strip(): continue target = grammar.parseString(target) extractPathExpression(requestContext, target) return list(pathExpressions)
def extractPathExpressions(targets): # Returns a list of unique pathExpressions found in the targets list pathExpressions = set() def extractPathExpression(tokens): if tokens.expression: return extractPathExpression(tokens.expression) elif tokens.pathExpression: pathExpressions.add(tokens.pathExpression) elif tokens.call: for a in tokens.call.args: extractPathExpression(a) for target in targets: tokens = grammar.parseString(target) extractPathExpression(tokens) return list(pathExpressions)
def extractPathExpressions(targets): # Returns a list of unique pathExpressions found in the targets list pathExpressions = [] def extractPathExpression(tokens): if tokens.expression: return extractPathExpression(tokens.expression) elif tokens.pathExpression: pathExpressions.append(tokens.pathExpression) elif tokens.call: [extractPathExpression(arg) for arg in tokens.call.args] for target in targets: tokens = grammar.parseString(target) extractPathExpression(tokens) s = set(pathExpressions) pathExpressions = list(s) return pathExpressions