ref: Use canonical keys everywhere in sentry itself (#10556)

src/sentry/api/endpoints/event_apple_crash_report.py

@@ -47,7 +47,7 @@ class EventAppleCrashReportEndpoint(Endpoint):
 
         threads = (event.data.get('threads') or {}).get('values')
         exceptions = (event.data.get(
-            'sentry.interfaces.Exception') or {}).get('values')
+            'exception') or {}).get('values')
 
         symbolicated = (request.GET.get('minified') not in ('1', 'true'))
         debug_images = None

src/sentry/api/serializers/models/event.py

@@ -33,7 +33,7 @@ class EventSerializer(Serializer):
 
             entry = {
                 'data': data,
-                'type': interface.get_alias(),
+                'type': interface.external_type,
             }
 
             api_meta = None

src/sentry/coreapi.py

@@ -180,12 +180,12 @@ class ClientApiHelper(object):
         return self.project_key_from_auth(auth).project_id
 
     def ensure_does_not_have_ip(self, data):
-        if 'sentry.interfaces.Http' in data:
-            if 'env' in data['sentry.interfaces.Http']:
-                data['sentry.interfaces.Http']['env'].pop('REMOTE_ADDR', None)
+        if 'request' in data:
+            if 'env' in data['request']:
+                data['request']['env'].pop('REMOTE_ADDR', None)
 
-        if 'sentry.interfaces.User' in data:
-            data['sentry.interfaces.User'].pop('ip_address', None)
+        if 'user' in data:
+            data['user'].pop('ip_address', None)
 
         if 'sdk' in data:
             data['sdk'].pop('client_ip', None)
@@ -235,7 +235,7 @@ class MinidumpApiHelper(ClientApiHelper):
 
 class SecurityApiHelper(ClientApiHelper):
 
-    report_interfaces = ('sentry.interfaces.Csp', 'hpkp', 'expectct', 'expectstaple')
+    report_interfaces = ('csp', 'hpkp', 'expectct', 'expectstaple')
 
     def origin_from_request(self, request):
         # In the case of security reports, the origin is not available at the

src/sentry/event_manager.py

@@ -71,7 +71,7 @@ HASH_RE = re.compile(r'^[0-9a-f]{32}$')
 DEFAULT_FINGERPRINT_VALUES = frozenset(['{{ default }}', '{{default}}'])
 ALLOWED_FUTURE_DELTA = timedelta(minutes=1)
 SECURITY_REPORT_INTERFACES = (
-    "sentry.interfaces.Csp",
+    "csp",
     "hpkp",
     "expectct",
     "expectstaple",
@@ -118,7 +118,7 @@ def get_hashes_for_event_with_reason(event):
         result = interface.compute_hashes(event.platform)
         if not result:
             continue
-        return (interface.get_path(), result)
+        return (interface.path, result)
 
     return ('no_interfaces', [''])
 
@@ -202,19 +202,19 @@ def generate_culprit(data, platform=None):
     culprit = ''
     try:
         stacktraces = [
-            e['stacktrace'] for e in data['sentry.interfaces.Exception']['values']
+            e['stacktrace'] for e in data['exception']['values']
             if e.get('stacktrace')
         ]
     except KeyError:
-        stacktrace = data.get('sentry.interfaces.Stacktrace')
+        stacktrace = data.get('stacktrace')
         if stacktrace:
             stacktraces = [stacktrace]
         else:
             stacktraces = None
 
     if not stacktraces:
-        if 'sentry.interfaces.Http' in data:
-            culprit = data['sentry.interfaces.Http'].get('url', '')
+        if 'request' in data:
+            culprit = data['request'].get('url', '')
     else:
         from sentry.interfaces.stacktrace import Stacktrace
         culprit = Stacktrace.to_python(stacktraces[-1]).get_culprit_string(
@@ -415,16 +415,16 @@ class EventManager(object):
                 'logger': 'csp',
                 'message': instance.get_message(),
                 'culprit': instance.get_culprit(),
-                instance.get_path(): instance.to_json(),
+                instance.path: instance.to_json(),
                 'tags': instance.get_tags(),
                 'errors': [],
-                'sentry.interfaces.User': {'ip_address': self._client_ip},
+                'user': {'ip_address': self._client_ip},
                 # Construct a faux Http interface based on the little information we have
                 # This is a bit weird, since we don't have nearly enough
                 # information to create an Http interface, but
                 # this automatically will pick up tags for the User-Agent
                 # which is actually important here for CSP
-                'sentry.interfaces.Http': {
+                'request': {
                     'url': instance.get_origin(),
                     'headers': clean(
                         {
@@ -513,14 +513,14 @@ class EventManager(object):
 
         # Fill in ip addresses marked as {{auto}}
         if self._client_ip:
-            if get_path(data, ['sentry.interfaces.Http', 'env', 'REMOTE_ADDR']) == '{{auto}}':
-                data['sentry.interfaces.Http']['env']['REMOTE_ADDR'] = self._client_ip
+            if get_path(data, ['request', 'env', 'REMOTE_ADDR']) == '{{auto}}':
+                data['request']['env']['REMOTE_ADDR'] = self._client_ip
 
             if get_path(data, ['request', 'env', 'REMOTE_ADDR']) == '{{auto}}':
                 data['request']['env']['REMOTE_ADDR'] = self._client_ip
 
-            if get_path(data, ['sentry.interfaces.User', 'ip_address']) == '{{auto}}':
-                data['sentry.interfaces.User']['ip_address'] = self._client_ip
+            if get_path(data, ['user', 'ip_address']) == '{{auto}}':
+                data['user']['ip_address'] = self._client_ip
 
             if get_path(data, ['user', 'ip_address']) == '{{auto}}':
                 data['user']['ip_address'] = self._client_ip
@@ -554,7 +554,7 @@ class EventManager(object):
 
             try:
                 inst = interface.to_python(value)
-                data[inst.get_path()] = inst.to_json()
+                data[inst.path] = inst.to_json()
             except Exception as e:
                 log = logger.debug if isinstance(
                     e, InterfaceValidationError) else logger.error
@@ -619,11 +619,11 @@ class EventManager(object):
         data['type'] = eventtypes.infer(data).key
         data['version'] = self.version
 
-        exception = data.get('sentry.interfaces.Exception')
-        stacktrace = data.get('sentry.interfaces.Stacktrace')
+        exception = data.get('exception')
+        stacktrace = data.get('stacktrace')
         if exception and len(exception['values']) == 1 and stacktrace:
             exception['values'][0]['stacktrace'] = stacktrace
-            del data['sentry.interfaces.Stacktrace']
+            del data['stacktrace']
 
         # Exception mechanism needs SDK information to resolve proper names in
         # exception meta (such as signal names). "SDK Information" really means
@@ -641,11 +641,11 @@ class EventManager(object):
         is_public = self._auth and self._auth.is_public
         add_ip_platforms = ('javascript', 'cocoa', 'objc')
 
-        http_ip = data.get('sentry.interfaces.Http', {}).get('env', {}).get('REMOTE_ADDR')
+        http_ip = data.get('request', {}).get('env', {}).get('REMOTE_ADDR')
         if http_ip:
-            data.setdefault('sentry.interfaces.User', {}).setdefault('ip_address', http_ip)
+            data.setdefault('user', {}).setdefault('ip_address', http_ip)
         elif self._client_ip and (is_public or data.get('platform') in add_ip_platforms):
-            data.setdefault('sentry.interfaces.User', {}).setdefault('ip_address', self._client_ip)
+            data.setdefault('user', {}).setdefault('ip_address', self._client_ip)
 
         # Trim values
         data['logger'] = trim(data['logger'].strip(), 64)
@@ -679,7 +679,7 @@ class EventManager(object):
         if release and not is_valid_release(self._project, release):
             return (True, FilterStatKeys.RELEASE_VERSION)
 
-        message_interface = self._data.get('sentry.interfaces.Message', {})
+        message_interface = self._data.get('logentry', {})
         error_message = message_interface.get('formatted', '') or message_interface.get(
             'message', ''
         )
@@ -687,7 +687,7 @@ class EventManager(object):
             return (True, FilterStatKeys.ERROR_MESSAGE)
 
         for exception_interface in self._data.get(
-            'sentry.interfaces.Exception', {}
+            'exception', {}
         ).get('values', []):
             message = u': '.join(
                 filter(None, map(exception_interface.get, ['type', 'value']))
@@ -849,7 +849,7 @@ class EventManager(object):
                 tags[k] = v
             # Get rid of ephemeral interface data
             if iface.ephemeral:
-                data.pop(iface.get_path(), None)
+                data.pop(iface.path, None)
 
         # tags are stored as a tuple
         tags = tags.items()
@@ -883,11 +883,11 @@ class EventManager(object):
         # index components into ``Event.message``
         # See GH-3248
         if event_type.key != 'default':
-            if 'sentry.interfaces.Message' in data and \
-                    data['sentry.interfaces.Message']['message'] != message:
+            if 'logentry' in data and \
+                    data['logentry']['message'] != message:
                 message = u'{} {}'.format(
                     message,
-                    data['sentry.interfaces.Message']['message'],
+                    data['logentry']['message'],
                 )
 
         if not message:
@@ -1158,7 +1158,7 @@ class EventManager(object):
         return event
 
     def _get_event_user(self, project, data):
-        user_data = data.get('sentry.interfaces.User')
+        user_data = data.get('user')
         if not user_data:
             return
 

src/sentry/eventtypes/base.py

@@ -29,7 +29,7 @@ class DefaultEvent(BaseEvent):
     def get_metadata(self):
         # See GH-3248
         message_interface = self.data.get(
-            'sentry.interfaces.Message', {
+            'logentry', {
                 'message': self.data.get('message', ''),
             }
         )

src/sentry/eventtypes/error.py

@@ -23,7 +23,7 @@ class ErrorEvent(BaseEvent):
 
     def has_metadata(self):
         try:
-            exception = self.data['sentry.interfaces.Exception']['values'][-1]
+            exception = self.data['exception']['values'][-1]
             exception['type']
             exception['value']
             return True
@@ -31,7 +31,7 @@ class ErrorEvent(BaseEvent):
             return False
 
     def get_metadata(self):
-        exception = self.data['sentry.interfaces.Exception']['values'][-1]
+        exception = self.data['exception']['values'][-1]
 
         # in some situations clients are submitting non-string data for these
         rv = {

src/sentry/eventtypes/security.py

@@ -8,13 +8,13 @@ class CspEvent(BaseEvent):
 
     def has_metadata(self):
         # TODO(alexh) also look for 'csp' ?
-        return 'sentry.interfaces.Csp' in self.data
+        return 'csp' in self.data
 
     def get_metadata(self):
         from sentry.interfaces.security import Csp
         # TODO(dcramer): pull get message into here to avoid instantiation
         # or ensure that these get interfaces passed instead of raw data
-        csp = Csp.to_python(self.data['sentry.interfaces.Csp'])
+        csp = Csp.to_python(self.data['csp'])
 
         return {
             'directive': csp.effective_directive,

src/sentry/filters/browser_extensions.py

@@ -79,14 +79,14 @@ class BrowserExtensionsFilter(Filter):
 
     def get_exception_value(self, data):
         try:
-            return data['sentry.interfaces.Exception']['values'][0]['value']
+            return data['exception']['values'][0]['value']
         except (LookupError, TypeError):
             return ''
 
     def get_exception_source(self, data):
         try:
-            return data['sentry.interfaces.Exception']['values'][0]['stacktrace']['frames'
-                                                                                  ][-1]['abs_path']
+            return data['exception']['values'][0]['stacktrace']['frames'
+                                                                ][-1]['abs_path']
         except (LookupError, TypeError):
             return ''
 

src/sentry/filters/legacy_browsers.py

@@ -81,7 +81,7 @@ class LegacyBrowsersFilter(Filter):
 
     def get_user_agent(self, data):
         try:
-            for key, value in data['sentry.interfaces.Http']['headers']:
+            for key, value in data['request']['headers']:
                 if key.lower() == 'user-agent':
                     return value
         except LookupError:

src/sentry/filters/localhost.py

@@ -15,13 +15,13 @@ class LocalhostFilter(Filter):
 
     def get_ip_address(self, data):
         try:
-            return data['sentry.interfaces.User']['ip_address']
+            return data['user']['ip_address']
         except KeyError:
             return ''
 
     def get_url(self, data):
         try:
-            return data['sentry.interfaces.Http']['url'] or ''
+            return data['request']['url'] or ''
         except KeyError:
             return ''