def test_checksum_rehashed(self):
checksum = "invalid checksum hash"
manager = EventManager(make_event(**{"checksum": checksum}))
manager.normalize()
event = manager.save(self.project.id)
hashes = [gh.hash for gh in GroupHash.objects.filter(group=event.group)]
assert sorted(hashes) == sorted([hash_from_values(checksum), checksum])
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 get_hash(self):
if not self.component.contributes:
return None
final_values = []
for value in self.values:
if value in DEFAULT_FINGERPRINT_VALUES:
final_values.extend(self.component.iter_values())
else:
final_values.append(value)
return hash_from_values(final_values)
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 d in DEFAULT_FINGERPRINT_VALUES else 0 for d in fingerprint)
# If no defaults are referenced we produce a single completely custom
# fingerprint.
if defaults_referenced == 0:
fingerprint = resolve_fingerprint_values(fingerprint, event)
return {"custom-fingerprint": CustomFingerprintVariant(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)
rv = {}
# If the fingerprints are unsalted, we can return them right away.
if defaults_referenced == 1 and len(fingerprint) == 1:
for (key, component) in six.iteritems(components):
rv[key] = ComponentVariant(component, config)
# Otherwise we need to salt each of the components.
else:
fingerprint = resolve_fingerprint_values(fingerprint, event)
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
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),
}
return {
'checksum':
ChecksumVariant(checksum),
'hashed-checksum':
ChecksumVariant(hash_from_values(checksum), hashed=True),
}
# Otherwise we go to the various forms of fingerprint handling.
fingerprint = event.data.get('fingerprint') or ['{{ default }}']
defaults_referenced = sum(1 if d in DEFAULT_FINGERPRINT_VALUES else 0
for d in fingerprint)
# If no defaults are referenced we produce a single completely custom
# fingerprint.
if defaults_referenced == 0:
fingerprint = resolve_fingerprint_values(fingerprint, event)
return {
'custom-fingerprint': CustomFingerprintVariant(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)
rv = {}
# If the fingerprints are unsalted, we can return them right away.
if defaults_referenced == 1 and len(fingerprint) == 1:
for (key, component) in six.iteritems(components):
rv[key] = ComponentVariant(component, config)
# Otherwise we need to salt each of the components.
else:
fingerprint = resolve_fingerprint_values(fingerprint, event)
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
def test_checksum_rehashed(self):
checksum = 'invalid checksum hash'
manager = EventManager(
make_event(**{
'checksum': checksum,
})
)
manager.normalize()
event = manager.save(self.project.id)
hashes = [gh.hash for gh in GroupHash.objects.filter(group=event.group)]
assert sorted(hashes) == sorted([hash_from_values(checksum), checksum])
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),
}
return {
'checksum': ChecksumVariant(checksum),
'hashed-checksum': ChecksumVariant(hash_from_values(checksum), hashed=True),
}
# Otherwise we go to the various forms of fingerprint handling.
fingerprint = event.data.get('fingerprint') or ['{{ default }}']
defaults_referenced = sum(1 if d in DEFAULT_FINGERPRINT_VALUES else 0 for d in fingerprint)
# If no defaults are referenced we produce a single completely custom
# fingerprint.
if defaults_referenced == 0:
return {
'custom-fingerprint': CustomFingerprintVariant(fingerprint),
}
# At this point we need to calculate the default event values. If the
# fingerprint is salted we will wrap it.
config = load_grouping_config(config)
components = _get_calculated_grouping_variants_for_event(event, config)
rv = {}
# If the fingerprints are unsalted, we can return them right away.
if defaults_referenced == 1 and len(fingerprint) == 1:
for (key, component) in six.iteritems(components):
rv[key] = ComponentVariant(component, config)
# Otherwise we need to salt each of the components.
else:
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
def get_hash(self):
return hash_from_values([])
def get_hash(self):
"""Returns the hash of the values if it contributes."""
if self.contributes:
return hash_from_values(self.iter_values())
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. If the event carries
# a materialized fingerprint info from server side fingerprinting we forward it to the
# variants which can export additional information about them.
fingerprint = event.data.get("fingerprint") or ["{{ default }}"]
fingerprint_info = event.data.get("_fingerprint_info")
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()
context = GroupingContext(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, context)
# 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 components.items():
component.update(
contributes=False,
contributes_to_similarity=True,
hint="custom fingerprint takes precedence",
)
rv[key] = ComponentVariant(component, context.config)
fingerprint = resolve_fingerprint_values(fingerprint, event.data)
rv["custom-fingerprint"] = CustomFingerprintVariant(fingerprint, fingerprint_info)
# If the fingerprints are unsalted, we can return them right away.
elif defaults_referenced == 1 and len(fingerprint) == 1:
rv = {}
for (key, component) in components.items():
rv[key] = ComponentVariant(component, context.config)
# Otherwise we need to salt each of the components.
else:
rv = {}
fingerprint = resolve_fingerprint_values(fingerprint, event.data)
for (key, component) in components.items():
rv[key] = SaltedComponentVariant(
fingerprint, component, context.config, fingerprint_info
)
# Ensure we have a fallback hash if nothing else works out
if not any(x.contributes for x in rv.values()):
rv["fallback"] = FallbackVariant()
return rv
def get_hash(self):
return hash_from_values([])
def test_hash_from_values():
result = hash_from_values(["foo", "bar", u"foô"])
assert result == "6d81588029ed4190110b2779ba952a00"
def get_hash(self):
"""Returns the hash of the values if it contributes."""
if self.contributes:
return hash_from_values(self.iter_values())
def test_hash_from_values():
result = hash_from_values(['foo', 'bar', u'foô'])
assert result == '6d81588029ed4190110b2779ba952a00'
