def reverse_tag_value(org_id: int, index: int) -> str:
str_value = indexer.reverse_resolve(org_id, index) # type: ignore
# If the value can't be reversed it's very likely a real programming bug
# instead of something to be caught down: We probably got back a value from
# Snuba that's not in the indexer => partial data loss
assert str_value is not None
return str_value # type: ignore
def _extract_data(self, entity, data, groups):
tags = tuple((key, data[key]) for key in sorted(data.keys()) if key.startswith("tags["))
metric_name = indexer.reverse_resolve(data["metric_id"])
ops = self._ops_by_metric[metric_name]
tag_data = groups.setdefault(
tags,
{
"totals": {},
"series": {},
},
)
timestamp = data.pop(TS_COL_GROUP, None)
for op in ops:
key = f"{op}({metric_name})"
series = tag_data["series"].setdefault(
key, len(self._intervals) * [_DEFAULT_AGGREGATES[op]]
)
field = _OP_TO_FIELD[entity][op]
value = data[field]
if field == "percentiles":
value = value[Percentile[op].value]
# If this is time series data, add it to the appropriate series.
# Else, add to totals
if timestamp is None:
tag_data["totals"][key] = finite_or_none(value)
else:
series_index = self._timestamp_index[timestamp]
series[series_index] = finite_or_none(value)
def translate_results(self):
groups = {}
for entity, subresults in self._results.items():
totals = subresults["totals"]["data"]
for data in totals:
self._extract_data(entity, data, groups)
series = subresults["series"]["data"]
for data in series:
self._extract_data(entity, data, groups)
org_id = self._organization_id
groups = [
dict(
by={
self._parse_tag(key):
indexer.reverse_resolve(org_id, value)
for key, value in tags
},
**data,
) for tags, data in groups.items()
]
return groups
def reverse_resolve(index: int) -> str:
assert index != 0
resolved = indexer.reverse_resolve(index)
# The indexer should never return None for integers > 0:
if resolved is None:
raise MetricIndexNotFound()
return resolved # type: ignore
def resolve_tags(results: Any, metrics_query: MetricsQueryBuilder) -> Any:
"""Go through the results of a metrics query and reverse resolve its tags"""
tags: List[str] = []
for column in metrics_query.columns:
if (
isinstance(column, AliasedExpression)
and column.exp.subscriptable == "tags"
and column.alias
):
tags.append(column.alias)
for tag in tags:
for row in results["data"]:
row[tag] = indexer.reverse_resolve(row[tag])
if tag in results["meta"]:
results["meta"][tag] = "string"
return results
def _parse_tag(self, tag_string: str) -> str:
tag_key = int(tag_string.replace("tags[", "").replace("]", ""))
return indexer.reverse_resolve(self._organization_id, tag_key)
def _parse_tag(self, tag_string: str) -> str:
tag_key = int(tag_string.replace("tags[", "").replace("]", ""))
return indexer.reverse_resolve(self._project_id, UseCase.TAG_KEY,
tag_key)
def _reverse_resolve(index: int) -> Optional[str]:
"""Wrapper for typing"""
return indexer.reverse_resolve(index) # type: ignore
def reverse_tag_value(org_id: int, index: int) -> str:
str_value = indexer.reverse_resolve(org_id, UseCase.TAG_VALUE,
index) # type: ignore
assert str_value is not None
return str_value # type: ignore
def reverse_resolve(index: int) -> str:
resolved = indexer.reverse_resolve(index)
# The indexer should never return None for integers > 0:
assert resolved is not None
return resolved
