def should_filter(self, project, data, ip_address=None):
"""
returns (result: bool, reason: string or None)
Result is True if an event should be filtered
The reason for filtering is passed along as a string
so that we can store it in metrics
"""
if ip_address and not is_valid_ip(project, ip_address):
return (True, FilterStatKeys.IP_ADDRESS)
release = data.get('release')
if release and not is_valid_release(project, release):
return (True, FilterStatKeys.RELEASE_VERSION)
message_interface = data.get('sentry.interfaces.Message', {})
error_message = message_interface.get('formatted', ''
) or message_interface.get('message', '')
if error_message and not is_valid_error_message(project, error_message):
return (True, FilterStatKeys.ERROR_MESSAGE)
for filter_cls in filters.all():
filter_obj = filter_cls(project)
if filter_obj.is_enabled() and filter_obj.test(data):
return (True, six.text_type(filter_obj.id))
return (False, None)
def should_filter(self, project, data, ip_address=None):
"""
returns (result: bool, reason: string or None)
Result is True if an event should be filtered
The reason for filtering is passed along as a string
so that we can store it in metrics
"""
if ip_address and not is_valid_ip(project, ip_address):
return (True, FilterStatKeys.IP_ADDRESS)
release = data.get('release')
if release and not is_valid_release(project, release):
return (True, FilterStatKeys.RELEASE_VERSION)
message_interface = data.get('sentry.interfaces.Message', {})
error_message = message_interface.get(
'formatted', '') or message_interface.get('message', '')
if error_message and not is_valid_error_message(
project, error_message):
return (True, FilterStatKeys.ERROR_MESSAGE)
for filter_cls in filters.all():
filter_obj = filter_cls(project)
if filter_obj.is_enabled() and filter_obj.test(data):
return (True, six.text_type(filter_obj.id))
return (False, None)
def should_filter(self, project, data, ip_address=None):
# TODO(dcramer): read filters from options such as:
# - ignore errors from spiders/bots
# - ignore errors from legacy browsers
if ip_address and not is_valid_ip(ip_address, project):
return True
for filter_cls in filters.all():
filter_obj = filter_cls(project)
if filter_obj.is_enabled() and filter_obj.test(data):
return True
return False
def should_filter(self, project, data, ip_address=None):
# TODO(dcramer): read filters from options such as:
# - ignore errors from spiders/bots
# - ignore errors from legacy browsers
if ip_address and not is_valid_ip(ip_address, project):
return True
for filter_cls in filters.all():
filter_obj = filter_cls(project)
if filter_obj.is_enabled() and filter_obj.test(data):
return True
return False
def should_filter(self):
'''
returns (result: bool, reason: string or None)
Result is True if an event should be filtered
The reason for filtering is passed along as a string
so that we can store it in metrics
'''
for name in SECURITY_REPORT_INTERFACES:
if name in self._data:
interface = get_interface(name)
if interface.to_python(self._data[name]).should_filter(
self._project):
return (True, FilterStatKeys.INVALID_CSP)
if self._client_ip and not is_valid_ip(self._project, self._client_ip):
return (True, FilterStatKeys.IP_ADDRESS)
release = self._data.get('release')
if release and not is_valid_release(self._project, release):
return (True, FilterStatKeys.RELEASE_VERSION)
error_message = get_path(self._data, 'logentry', 'formatted') \
or get_path(self._data, 'logentry', 'message') \
or ''
if error_message and not is_valid_error_message(
self._project, error_message):
return (True, FilterStatKeys.ERROR_MESSAGE)
for exc in get_path(self._data,
'exception',
'values',
filter=True,
default=[]):
message = u': '.join(filter(None, map(exc.get, ['type', 'value'])))
if message and not is_valid_error_message(self._project, message):
return (True, FilterStatKeys.ERROR_MESSAGE)
for filter_cls in filters.all():
filter_obj = filter_cls(self._project)
if filter_obj.is_enabled() and filter_obj.test(self._data):
return (True, six.text_type(filter_obj.id))
return (False, None)
def get(self, request, project):
"""
List a project's filters
Retrieve a list of filters for a given project.
{method} {path}
"""
results = []
for f_cls in filters.all():
filter = f_cls(project)
results.append({
'id': filter.id,
'active': filter.is_enabled(),
'description': filter.description,
'name': filter.name,
})
results.sort(key=lambda x: x['name'])
return Response(results)
def get(self, request, project):
"""
List a project's filters
Retrieve a list of filters for a given project.
{method} {path}
"""
results = []
for f_cls in filters.all():
filter = f_cls(project)
results.append({
'id': filter.id,
# 'active' will be either a boolean or list for the legacy browser filters
# all other filters will be boolean
'active': filter.is_enabled(),
'description': filter.description,
'name': filter.name,
})
results.sort(key=lambda x: x['name'])
return Response(results)
def should_filter(self):
'''
returns (result: bool, reason: string or None)
Result is True if an event should be filtered
The reason for filtering is passed along as a string
so that we can store it in metrics
'''
for name in SECURITY_REPORT_INTERFACES:
if name in self._data:
interface = get_interface(name)
if interface.to_python(self._data[name]).should_filter(self._project):
return (True, FilterStatKeys.INVALID_CSP)
if self._client_ip and not is_valid_ip(self._project, self._client_ip):
return (True, FilterStatKeys.IP_ADDRESS)
release = self._data.get('release')
if release and not is_valid_release(self._project, release):
return (True, FilterStatKeys.RELEASE_VERSION)
error_message = get_path(self._data, 'logentry', 'formatted') \
or get_path(self._data, 'logentry', 'message') \
or ''
if error_message and not is_valid_error_message(self._project, error_message):
return (True, FilterStatKeys.ERROR_MESSAGE)
for exc in get_path(self._data, 'exception', 'values', filter=True, default=[]):
message = u': '.join(
filter(None, map(exc.get, ['type', 'value']))
)
if message and not is_valid_error_message(self._project, message):
return (True, FilterStatKeys.ERROR_MESSAGE)
for filter_cls in filters.all():
filter_obj = filter_cls(self._project)
if filter_obj.is_enabled() and filter_obj.test(self._data):
return (True, six.text_type(filter_obj.id))
return (False, None)
def get_full_relay_config(project_id):
"""
Constructs the internal (big) RelayConfig
:param project_id: the project id as int or string
:return: FullRelayConfig the relay configuration
"""
cfg = {}
project = _get_project_from_id(six.text_type(project_id))
if project is None:
raise APIError("Invalid project id:{}".format(project_id))
cfg['project_id'] = project.id
cfg['organization_id'] = project.organization_id
# Explicitly bind Organization so we don't implicitly query it later
# this just allows us to comfortably assure that `project.organization` is safe.
# This also allows us to pull the object from cache, instead of being
# implicitly fetched from database.
project.organization = Organization.objects.get_from_cache(
id=project.organization_id)
if project.organization is not None:
org_options = OrganizationOption.objects.get_all_values(
project.organization_id)
else:
org_options = {}
# get the project options
project_cfg = {}
cfg['config'] = project_cfg
# getting kafka info
try:
project_cfg['kafka_max_event_size'] = options.get(
'kafka-publisher.max-event-size')
project_cfg['kafka_raw_event_sample_rate'] = options.get(
'kafka-publisher.raw-event-sample-rate')
except Exception:
pass # should we log ?
invalid_releases = project.get_option(u'sentry:{}'.format(
FilterTypes.RELEASES))
if invalid_releases is not None:
project_cfg['invalid_releases'] = invalid_releases
# get the filters enabled for the current project
enabled_filters = [
filter_class.id for filter_class in filters.all()
if filter_class(project).is_enabled()
]
project_cfg['enabled_filters'] = enabled_filters
scrub_ip_address = (
org_options.get('sentry:require_scrub_ip_address', False)
or project.get_option('sentry:scrub_ip_address', False))
project_cfg['scrub_ip_addresses'] = scrub_ip_address
scrub_data = (org_options.get('sentry:require_scrub_data', False)
or project.get_option('sentry:scrub_data', True))
project_cfg['scrub_data'] = scrub_data
project_cfg['grouping_config'] = get_grouping_config_dict_for_project(
project)
project_cfg['allowed_domains'] = list(get_origins(project))
if scrub_data:
# We filter data immediately before it ever gets into the queue
sensitive_fields_key = 'sentry:sensitive_fields'
sensitive_fields = (org_options.get(sensitive_fields_key, []) +
project.get_option(sensitive_fields_key, []))
project_cfg['sensitive_fields'] = sensitive_fields
exclude_fields_key = 'sentry:safe_fields'
exclude_fields = (org_options.get(exclude_fields_key, []) +
project.get_option(exclude_fields_key, []))
project_cfg['exclude_fields'] = exclude_fields
scrub_defaults = (org_options.get('sentry:require_scrub_defaults',
False)
or project.get_option('sentry:scrub_defaults', True))
project_cfg['scrub_defaults'] = scrub_defaults
return FullRelayConfig(project, **cfg)
