def encode_for_similarity(self):
for x in ComponentVariant.encode_for_similarity(self):
yield x
for value in self.values:
if not is_default_fingerprint_var(value):
yield ("fingerprint", "ident-shingle"), [value]
def get_hash(self):
if not self.component.contributes:
return None
final_values = []
for value in self.values:
if is_default_fingerprint_var(value):
final_values.extend(self.component.iter_values())
else:
final_values.append(value)
return hash_from_values(final_values)
def expose_fingerprint_dict(values, info=None):
rv = {
"values": values,
}
if not info:
return rv
from sentry.grouping.fingerprinting import Rule
client_values = info.get("client_fingerprint")
if client_values and (len(client_values) != 1
or not is_default_fingerprint_var(client_values[0])):
rv["client_values"] = client_values
matched_rule = info.get("matched_rule")
if matched_rule:
rule = Rule.from_json(matched_rule)
rv["matched_rule"] = rule.text
return rv
def get_grouping_variants_for_event(event, config=None):
"""Returns a dict of all grouping variants for this event."""
# If a checksum is set the only variant that comes back from this
# event is the checksum variant.
checksum = event.data.get("checksum")
if checksum:
if HASH_RE.match(checksum):
return {"checksum": ChecksumVariant(checksum)}
rv = {
"hashed-checksum": ChecksumVariant(hash_from_values(checksum), hashed=True),
}
# The legacy code path also supported arbitrary values here but
# it will blow up if it results in more than 32 bytes of data
# as this cannot be inserted into the database. (See GroupHash.hash)
if len(checksum) <= 32:
rv["checksum"] = ChecksumVariant(checksum)
return rv
# Otherwise we go to the various forms of fingerprint handling.
fingerprint = event.data.get("fingerprint") or ["{{ default }}"]
defaults_referenced = sum(1 if is_default_fingerprint_var(d) else 0 for d in fingerprint)
if config is None:
config = load_default_grouping_config()
# At this point we need to calculate the default event values. If the
# fingerprint is salted we will wrap it.
components = _get_calculated_grouping_variants_for_event(event, config)
# If no defaults are referenced we produce a single completely custom
# fingerprint and mark all other variants as non-contributing
if defaults_referenced == 0:
rv = {}
for (key, component) in six.iteritems(components):
component.update(
contributes=False,
contributes_to_similarity=True,
hint="custom fingerprint takes precedence",
)
rv[key] = ComponentVariant(component, config)
fingerprint = resolve_fingerprint_values(fingerprint, event.data)
rv["custom-fingerprint"] = CustomFingerprintVariant(fingerprint)
# If the fingerprints are unsalted, we can return them right away.
elif defaults_referenced == 1 and len(fingerprint) == 1:
rv = {}
for (key, component) in six.iteritems(components):
rv[key] = ComponentVariant(component, config)
# Otherwise we need to salt each of the components.
else:
rv = {}
fingerprint = resolve_fingerprint_values(fingerprint, event.data)
for (key, component) in six.iteritems(components):
rv[key] = SaltedComponentVariant(fingerprint, component, config)
# Ensure we have a fallback hash if nothing else works out
if not any(x.contributes for x in six.itervalues(rv)):
rv["fallback"] = FallbackVariant()
return rv
