exceptions: added new exception tracking capability.

- store exceptions
- expose super admin interface to browse latest errors

rhodecode/apps/admin/views/exception_tracker.py

@@ -0,0 +1,153 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2018-2018 RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+import os
+import logging
+
+from pyramid.httpexceptions import HTTPFound
+from pyramid.view import view_config
+
+from rhodecode.apps._base import BaseAppView
+from rhodecode.apps.admin.navigation import navigation_list
+from rhodecode.lib import helpers as h
+from rhodecode.lib.auth import (
+    LoginRequired, HasPermissionAllDecorator, CSRFRequired)
+from rhodecode.lib.utils2 import time_to_utcdatetime
+from rhodecode.lib import exc_tracking
+
+log = logging.getLogger(__name__)
+
+
+class ExceptionsTrackerView(BaseAppView):
+    def load_default_context(self):
+        c = self._get_local_tmpl_context()
+        c.navlist = navigation_list(self.request)
+        return c
+
+    def count_all_exceptions(self):
+        exc_store_path = exc_tracking.get_exc_store()
+        count = 0
+        for fname in os.listdir(exc_store_path):
+            parts = fname.split('_', 2)
+            if not len(parts) == 3:
+                continue
+            count +=1
+        return count
+
+    def get_all_exceptions(self, read_metadata=False, limit=None):
+        exc_store_path = exc_tracking.get_exc_store()
+        exception_list = []
+
+        def key_sorter(val):
+            try:
+                return val.split('_')[-1]
+            except Exception:
+                return 0
+        count = 0
+        for fname in reversed(sorted(os.listdir(exc_store_path), key=key_sorter)):
+
+            parts = fname.split('_', 2)
+            if not len(parts) == 3:
+                continue
+
+            exc_id, app_type, exc_timestamp = parts
+
+            exc = {'exc_id': exc_id, 'app_type': app_type, 'exc_type': 'unknown',
+                   'exc_utc_date': '', 'exc_timestamp': exc_timestamp}
+
+            if read_metadata:
+                full_path = os.path.join(exc_store_path, fname)
+                # we can read our metadata
+                with open(full_path, 'rb') as f:
+                    exc_metadata = exc_tracking.exc_unserialize(f.read())
+                    exc.update(exc_metadata)
+
+            # convert our timestamp to a date obj, for nicer representation
+            exc['exc_utc_date'] = time_to_utcdatetime(exc['exc_timestamp'])
+            exception_list.append(exc)
+
+            count += 1
+            if limit and count >= limit:
+                break
+        return exception_list
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @view_config(
+        route_name='admin_settings_exception_tracker', request_method='GET',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def browse_exceptions(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+        c.active = 'exceptions_browse'
+        c.limit = self.request.GET.get('limit', 50)
+        c.exception_list = self.get_all_exceptions(read_metadata=True, limit=c.limit)
+        c.exception_list_count = self.count_all_exceptions()
+        c.exception_store_dir = exc_tracking.get_exc_store()
+        return self._get_template_context(c)
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @view_config(
+        route_name='admin_settings_exception_tracker_show', request_method='GET',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def exception_show(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+
+        c.active = 'exceptions'
+        c.exception_id = self.request.matchdict['exception_id']
+        c.traceback = exc_tracking.read_exception(c.exception_id, prefix=None)
+        return self._get_template_context(c)
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='admin_settings_exception_tracker_delete_all', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def exception_delete_all(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+
+        c.active = 'exceptions'
+        all_exc = self.get_all_exceptions()
+        exc_count = len(all_exc)
+        for exc in all_exc:
+            exc_tracking.delete_exception(exc['exc_id'], prefix=None)
+
+        h.flash(_('Removed {} Exceptions').format(exc_count), category='success')
+        raise HTTPFound(h.route_path('admin_settings_exception_tracker'))
+
+    @LoginRequired()
+    @HasPermissionAllDecorator('hg.admin')
+    @CSRFRequired()
+    @view_config(
+        route_name='admin_settings_exception_tracker_delete', request_method='POST',
+        renderer='rhodecode:templates/admin/settings/settings.mako')
+    def exception_delete(self):
+        _ = self.request.translate
+        c = self.load_default_context()
+
+        c.active = 'exceptions'
+        c.exception_id = self.request.matchdict['exception_id']
+        exc_tracking.delete_exception(c.exception_id, prefix=None)
+
+        h.flash(_('Removed Exception {}').format(c.exception_id), category='success')
+        raise HTTPFound(h.route_path('admin_settings_exception_tracker'))

rhodecode/lib/exc_tracking.py

@@ -0,0 +1,146 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2010-2018 RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+import os
+import time
+import datetime
+import msgpack
+import logging
+import traceback
+import tempfile
+
+
+log = logging.getLogger(__name__)
+
+# NOTE: Any changes should be synced with exc_tracking at vcsserver.lib.exc_tracking
+global_prefix = 'rhodecode'
+
+
+def exc_serialize(exc_id, tb, exc_type):
+
+    data = {
+        'version': 'v1',
+        'exc_id': exc_id,
+        'exc_utc_date': datetime.datetime.utcnow().isoformat(),
+        'exc_timestamp': repr(time.time()),
+        'exc_message': tb,
+        'exc_type': exc_type,
+    }
+    return msgpack.packb(data), data
+
+
+def exc_unserialize(tb):
+    return msgpack.unpackb(tb)
+
+
+def get_exc_store():
+    """
+    Get and create exception store if it's not existing
+    """
+    exc_store_dir = 'rc_exception_store_v1'
+    # fallback
+    _exc_store_path = os.path.join(tempfile.gettempdir(), exc_store_dir)
+
+    exc_store_dir = ''  # TODO: need a persistent cross instance store here
+    if exc_store_dir:
+        _exc_store_path = os.path.join(exc_store_dir, exc_store_dir)
+
+    _exc_store_path = os.path.abspath(_exc_store_path)
+    if not os.path.isdir(_exc_store_path):
+        os.makedirs(_exc_store_path)
+        log.debug('Initializing exceptions store at %s', _exc_store_path)
+    return _exc_store_path
+
+
+def _store_exception(exc_id, exc_info, prefix):
+    exc_type, exc_value, exc_traceback = exc_info
+    tb = ''.join(traceback.format_exception(
+        exc_type, exc_value, exc_traceback, None))
+
+    exc_type_name = exc_type.__name__
+    exc_store_path = get_exc_store()
+    exc_data, org_data = exc_serialize(exc_id, tb, exc_type_name)
+    exc_pref_id = '{}_{}_{}'.format(exc_id, prefix, org_data['exc_timestamp'])
+    if not os.path.isdir(exc_store_path):
+        os.makedirs(exc_store_path)
+    stored_exc_path = os.path.join(exc_store_path, exc_pref_id)
+    with open(stored_exc_path, 'wb') as f:
+        f.write(exc_data)
+    log.debug('Stored generated exception %s as: %s', exc_id, stored_exc_path)
+
+
+def store_exception(exc_id, exc_info, prefix=global_prefix):
+    try:
+        _store_exception(exc_id=exc_id, exc_info=exc_info, prefix=prefix)
+    except Exception:
+        log.exception('Failed to store exception `%s` information', exc_id)
+        # there's no way this can fail, it will crash server badly if it does.
+        pass
+
+
+def _find_exc_file(exc_id, prefix=global_prefix):
+    exc_store_path = get_exc_store()
+    if prefix:
+        exc_id = '{}_{}'.format(exc_id, prefix)
+    else:
+        # search without a prefix
+        exc_id = '{}'.format(exc_id)
+
+    # we need to search the store for such start pattern as above
+    for fname in os.listdir(exc_store_path):
+        if fname.startswith(exc_id):
+            exc_id = os.path.join(exc_store_path, fname)
+            break
+        continue
+    else:
+        exc_id = None
+
+    return exc_id
+
+
+def _read_exception(exc_id, prefix):
+    exc_id_file_path = _find_exc_file(exc_id=exc_id, prefix=prefix)
+    if exc_id_file_path:
+        with open(exc_id_file_path, 'rb') as f:
+            return exc_unserialize(f.read())
+    else:
+        log.debug('Exception File `%s` not found', exc_id_file_path)
+    return None
+
+
+def read_exception(exc_id, prefix=global_prefix):
+    try:
+        return _read_exception(exc_id=exc_id, prefix=prefix)
+    except Exception:
+        log.exception('Failed to read exception `%s` information', exc_id)
+        # there's no way this can fail, it will crash server badly if it does.
+    return None
+
+
+def delete_exception(exc_id, prefix=global_prefix):
+    try:
+        exc_id_file_path = _find_exc_file(exc_id, prefix=prefix)
+        if exc_id_file_path:
+            os.remove(exc_id_file_path)
+
+    except Exception:
+        log.exception('Failed to remove exception `%s` information', exc_id)
+        # there's no way this can fail, it will crash server badly if it does.
+        pass

rhodecode/templates/admin/settings/settings_exceptions.mako

@@ -0,0 +1,38 b''
+<div class="panel panel-default">
+    <div class="panel-heading">
+        <h3 class="panel-title">${_('Exceptions Tracker - Exception ID')}: ${c.exception_id}</h3>
+    </div>
+    <div class="panel-body">
+    % if c.traceback:
+
+    <h4>${_('Exception `{}` generated on UTC date: {}').format(c.traceback.get('exc_type', 'NO_TYPE'), c.traceback.get('exc_utc_date', 'NO_DATE'))}</h4>
+    <pre>${c.traceback.get('exc_message', 'NO_MESSAGE')}</pre>
+
+    % else:
+        ${_('Unable to Read Exception. It might be removed or non-existing.')}
+    % endif
+    </div>
+</div>
+
+
+% if c.traceback:
+<div class="panel panel-danger">
+    <div class="panel-heading" id="advanced-delete">
+        <h3 class="panel-title">${_('Delete this Exception')}</h3>
+    </div>
+    <div class="panel-body">
+      ${h.secure_form(h.route_path('admin_settings_exception_tracker_delete', exception_id=c.exception_id), request=request)}
+        <div style="margin: 0 0 20px 0" class="fake-space"></div>
+
+        <div class="field">
+            <button class="btn btn-small btn-danger" type="submit"
+                    onclick="return confirm('${_('Confirm to delete this exception')}');">
+                <i class="icon-remove-sign"></i>
+                ${_('Delete This Exception')}
+            </button>
+        </div>
+
+      ${h.end_form()}
+    </div>
+</div>
+% endif

rhodecode/templates/admin/settings/settings_exceptions_browse.mako

@@ -0,0 +1,52 b''
+<div class="panel panel-default">
+    <div class="panel-heading">
+        <h3 class="panel-title">${_('Exceptions Tracker ')}</h3>
+    </div>
+    <div class="panel-body">
+        % if c.exception_list_count == 1:
+            ${_('There is {} stored exception.').format(c.exception_list_count)}
+        % else:
+            ${_('There are {} stored exceptions.').format(c.exception_list_count)}
+        % endif
+        ${_('Store directory')}: ${c.exception_store_dir}
+
+      ${h.secure_form(h.route_path('admin_settings_exception_tracker_delete_all'), request=request)}
+        <div style="margin: 0 0 20px 0" class="fake-space"></div>
+
+        <div class="field">
+            <button class="btn btn-small btn-danger" type="submit"
+                    onclick="return confirm('${_('Confirm to delete all exceptions')}');">
+                <i class="icon-remove-sign"></i>
+                ${_('Delete All')}
+            </button>
+        </div>
+
+      ${h.end_form()}
+
+    </div>
+</div>
+
+
+<div class="panel panel-default">
+    <div class="panel-heading">
+        <h3 class="panel-title">${_('Exceptions Tracker - Showing the last {} Exceptions').format(c.limit)}</h3>
+    </div>
+    <div class="panel-body">
+        <table class="rctable">
+        <tr>
+            <th>Exception ID</th>
+            <th>Date</th>
+            <th>App Type</th>
+            <th>Exc Type</th>
+        </tr>
+        % for tb in c.exception_list:
+            <tr>
+                <td><a href="${h.route_path('admin_settings_exception_tracker_show', exception_id=tb['exc_id'])}"><code>${tb['exc_id']}</code></a></td>
+                <td>${h.format_date(tb['exc_utc_date'])}</td>
+                <td>${tb['app_type']}</td>
+                <td>${tb['exc_type']}</td>
+            </tr>
+        % endfor
+        </table>
+    </div>
+</div>

rhodecode/apps/admin/__init__.py

@@ -1,426 +1,439 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 from rhodecode.apps._base import ADMIN_PREFIX
 
 
 def admin_routes(config):
     """
     Admin prefixed routes
     """
 
     config.add_route(
         name='admin_audit_logs',
         pattern='/audit_logs')
 
     config.add_route(
         name='admin_audit_log_entry',
         pattern='/audit_logs/{audit_log_id}')
 
     config.add_route(
         name='pull_requests_global_0',  # backward compat
         pattern='/pull_requests/{pull_request_id:\d+}')
     config.add_route(
         name='pull_requests_global_1',  # backward compat
         pattern='/pull-requests/{pull_request_id:\d+}')
     config.add_route(
         name='pull_requests_global',
         pattern='/pull-request/{pull_request_id:\d+}')
 
     config.add_route(
         name='admin_settings_open_source',
         pattern='/settings/open_source')
     config.add_route(
         name='admin_settings_vcs_svn_generate_cfg',
         pattern='/settings/vcs/svn_generate_cfg')
 
     config.add_route(
         name='admin_settings_system',
         pattern='/settings/system')
     config.add_route(
         name='admin_settings_system_update',
         pattern='/settings/system/updates')
 
     config.add_route(
+        name='admin_settings_exception_tracker',
+        pattern='/settings/exceptions')
+    config.add_route(
+        name='admin_settings_exception_tracker_delete_all',
+        pattern='/settings/exceptions/delete')
+    config.add_route(
+        name='admin_settings_exception_tracker_show',
+        pattern='/settings/exceptions/{exception_id}')
+    config.add_route(
+        name='admin_settings_exception_tracker_delete',
+        pattern='/settings/exceptions/{exception_id}/delete')
+
+    config.add_route(
         name='admin_settings_sessions',
         pattern='/settings/sessions')
     config.add_route(
         name='admin_settings_sessions_cleanup',
         pattern='/settings/sessions/cleanup')
 
     config.add_route(
         name='admin_settings_process_management',
         pattern='/settings/process_management')
     config.add_route(
         name='admin_settings_process_management_data',
         pattern='/settings/process_management/data')
     config.add_route(
         name='admin_settings_process_management_signal',
         pattern='/settings/process_management/signal')
     config.add_route(
         name='admin_settings_process_management_master_signal',
         pattern='/settings/process_management/master_signal')
 
     # default settings
     config.add_route(
         name='admin_defaults_repositories',
         pattern='/defaults/repositories')
     config.add_route(
         name='admin_defaults_repositories_update',
         pattern='/defaults/repositories/update')
 
     # admin settings
 
     config.add_route(
         name='admin_settings',
         pattern='/settings')
     config.add_route(
         name='admin_settings_update',
         pattern='/settings/update')
 
     config.add_route(
         name='admin_settings_global',
         pattern='/settings/global')
     config.add_route(
         name='admin_settings_global_update',
         pattern='/settings/global/update')
 
     config.add_route(
         name='admin_settings_vcs',
         pattern='/settings/vcs')
     config.add_route(
         name='admin_settings_vcs_update',
         pattern='/settings/vcs/update')
     config.add_route(
         name='admin_settings_vcs_svn_pattern_delete',
         pattern='/settings/vcs/svn_pattern_delete')
 
     config.add_route(
         name='admin_settings_mapping',
         pattern='/settings/mapping')
     config.add_route(
         name='admin_settings_mapping_update',
         pattern='/settings/mapping/update')
 
     config.add_route(
         name='admin_settings_visual',
         pattern='/settings/visual')
     config.add_route(
         name='admin_settings_visual_update',
         pattern='/settings/visual/update')
 
 
     config.add_route(
         name='admin_settings_issuetracker',
         pattern='/settings/issue-tracker')
     config.add_route(
         name='admin_settings_issuetracker_update',
         pattern='/settings/issue-tracker/update')
     config.add_route(
         name='admin_settings_issuetracker_test',
         pattern='/settings/issue-tracker/test')
     config.add_route(
         name='admin_settings_issuetracker_delete',
         pattern='/settings/issue-tracker/delete')
 
     config.add_route(
         name='admin_settings_email',
         pattern='/settings/email')
     config.add_route(
         name='admin_settings_email_update',
         pattern='/settings/email/update')
 
     config.add_route(
         name='admin_settings_hooks',
         pattern='/settings/hooks')
     config.add_route(
         name='admin_settings_hooks_update',
         pattern='/settings/hooks/update')
     config.add_route(
         name='admin_settings_hooks_delete',
         pattern='/settings/hooks/delete')
 
     config.add_route(
         name='admin_settings_search',
         pattern='/settings/search')
 
     config.add_route(
         name='admin_settings_labs',
         pattern='/settings/labs')
     config.add_route(
         name='admin_settings_labs_update',
         pattern='/settings/labs/update')
 
     # Automation EE feature
     config.add_route(
         'admin_settings_automation',
         pattern=ADMIN_PREFIX + '/settings/automation')
 
     # global permissions
 
     config.add_route(
         name='admin_permissions_application',
         pattern='/permissions/application')
     config.add_route(
         name='admin_permissions_application_update',
         pattern='/permissions/application/update')
 
     config.add_route(
         name='admin_permissions_global',
         pattern='/permissions/global')
     config.add_route(
         name='admin_permissions_global_update',
         pattern='/permissions/global/update')
 
     config.add_route(
         name='admin_permissions_object',
         pattern='/permissions/object')
     config.add_route(
         name='admin_permissions_object_update',
         pattern='/permissions/object/update')
 
     config.add_route(
         name='admin_permissions_ips',
         pattern='/permissions/ips')
 
     config.add_route(
         name='admin_permissions_overview',
         pattern='/permissions/overview')
 
     config.add_route(
         name='admin_permissions_auth_token_access',
         pattern='/permissions/auth_token_access')
 
     config.add_route(
         name='admin_permissions_ssh_keys',
         pattern='/permissions/ssh_keys')
     config.add_route(
         name='admin_permissions_ssh_keys_data',
         pattern='/permissions/ssh_keys/data')
     config.add_route(
         name='admin_permissions_ssh_keys_update',
         pattern='/permissions/ssh_keys/update')
 
     # users admin
     config.add_route(
         name='users',
         pattern='/users')
 
     config.add_route(
         name='users_data',
         pattern='/users_data')
 
     config.add_route(
         name='users_create',
         pattern='/users/create')
 
     config.add_route(
         name='users_new',
         pattern='/users/new')
 
     # user management
     config.add_route(
         name='user_edit',
         pattern='/users/{user_id:\d+}/edit',
         user_route=True)
     config.add_route(
         name='user_edit_advanced',
         pattern='/users/{user_id:\d+}/edit/advanced',
         user_route=True)
     config.add_route(
         name='user_edit_global_perms',
         pattern='/users/{user_id:\d+}/edit/global_permissions',
         user_route=True)
     config.add_route(
         name='user_edit_global_perms_update',
         pattern='/users/{user_id:\d+}/edit/global_permissions/update',
         user_route=True)
     config.add_route(
         name='user_update',
         pattern='/users/{user_id:\d+}/update',
         user_route=True)
     config.add_route(
         name='user_delete',
         pattern='/users/{user_id:\d+}/delete',
         user_route=True)
     config.add_route(
         name='user_force_password_reset',
         pattern='/users/{user_id:\d+}/password_reset',
         user_route=True)
     config.add_route(
         name='user_create_personal_repo_group',
         pattern='/users/{user_id:\d+}/create_repo_group',
         user_route=True)
 
     # user auth tokens
     config.add_route(
         name='edit_user_auth_tokens',
         pattern='/users/{user_id:\d+}/edit/auth_tokens',
         user_route=True)
     config.add_route(
         name='edit_user_auth_tokens_add',
         pattern='/users/{user_id:\d+}/edit/auth_tokens/new',
         user_route=True)
     config.add_route(
         name='edit_user_auth_tokens_delete',
         pattern='/users/{user_id:\d+}/edit/auth_tokens/delete',
         user_route=True)
 
     # user ssh keys
     config.add_route(
         name='edit_user_ssh_keys',
         pattern='/users/{user_id:\d+}/edit/ssh_keys',
         user_route=True)
     config.add_route(
         name='edit_user_ssh_keys_generate_keypair',
         pattern='/users/{user_id:\d+}/edit/ssh_keys/generate',
         user_route=True)
     config.add_route(
         name='edit_user_ssh_keys_add',
         pattern='/users/{user_id:\d+}/edit/ssh_keys/new',
         user_route=True)
     config.add_route(
         name='edit_user_ssh_keys_delete',
         pattern='/users/{user_id:\d+}/edit/ssh_keys/delete',
         user_route=True)
 
     # user emails
     config.add_route(
         name='edit_user_emails',
         pattern='/users/{user_id:\d+}/edit/emails',
         user_route=True)
     config.add_route(
         name='edit_user_emails_add',
         pattern='/users/{user_id:\d+}/edit/emails/new',
         user_route=True)
     config.add_route(
         name='edit_user_emails_delete',
         pattern='/users/{user_id:\d+}/edit/emails/delete',
         user_route=True)
 
     # user IPs
     config.add_route(
         name='edit_user_ips',
         pattern='/users/{user_id:\d+}/edit/ips',
         user_route=True)
     config.add_route(
         name='edit_user_ips_add',
         pattern='/users/{user_id:\d+}/edit/ips/new',
         user_route_with_default=True)  # enabled for default user too
     config.add_route(
         name='edit_user_ips_delete',
         pattern='/users/{user_id:\d+}/edit/ips/delete',
         user_route_with_default=True)  # enabled for default user too
 
     # user perms
     config.add_route(
         name='edit_user_perms_summary',
         pattern='/users/{user_id:\d+}/edit/permissions_summary',
         user_route=True)
     config.add_route(
         name='edit_user_perms_summary_json',
         pattern='/users/{user_id:\d+}/edit/permissions_summary/json',
         user_route=True)
 
     # user user groups management
     config.add_route(
         name='edit_user_groups_management',
         pattern='/users/{user_id:\d+}/edit/groups_management',
         user_route=True)
 
     config.add_route(
         name='edit_user_groups_management_updates',
         pattern='/users/{user_id:\d+}/edit/edit_user_groups_management/updates',
         user_route=True)
 
     # user audit logs
     config.add_route(
         name='edit_user_audit_logs',
         pattern='/users/{user_id:\d+}/edit/audit', user_route=True)
 
     # user caches
     config.add_route(
         name='edit_user_caches',
         pattern='/users/{user_id:\d+}/edit/caches',
         user_route=True)
     config.add_route(
         name='edit_user_caches_update',
         pattern='/users/{user_id:\d+}/edit/caches/update',
         user_route=True)
 
     # user-groups admin
     config.add_route(
         name='user_groups',
         pattern='/user_groups')
 
     config.add_route(
         name='user_groups_data',
         pattern='/user_groups_data')
 
     config.add_route(
         name='user_groups_new',
         pattern='/user_groups/new')
 
     config.add_route(
         name='user_groups_create',
         pattern='/user_groups/create')
 
     # repos admin
     config.add_route(
         name='repos',
         pattern='/repos')
 
     config.add_route(
         name='repo_new',
         pattern='/repos/new')
 
     config.add_route(
         name='repo_create',
         pattern='/repos/create')
 
     # repo groups admin
     config.add_route(
         name='repo_groups',
         pattern='/repo_groups')
 
     config.add_route(
         name='repo_group_new',
         pattern='/repo_group/new')
 
     config.add_route(
         name='repo_group_create',
         pattern='/repo_group/create')
 
 
 def includeme(config):
     from rhodecode.apps.admin.navigation import includeme as nav_includeme
 
     # Create admin navigation registry and add it to the pyramid registry.
     nav_includeme(config)
 
     # main admin routes
     config.add_route(name='admin_home', pattern=ADMIN_PREFIX)
     config.include(admin_routes, route_prefix=ADMIN_PREFIX)
 
     config.include('.subscribers')
 
     # Scan module for configuration decorators.
     config.scan('.views', ignore='.tests')

rhodecode/apps/admin/navigation.py

@@ -1,144 +1,147 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import logging
 import collections
 
 from zope.interface import implementer
 
 from rhodecode.apps.admin.interfaces import IAdminNavigationRegistry
 from rhodecode.lib.utils2 import str2bool
 from rhodecode.translation import _
 
 
 log = logging.getLogger(__name__)
 
 NavListEntry = collections.namedtuple(
     'NavListEntry', ['key', 'name', 'url', 'active_list'])
 
 
 class NavEntry(object):
     """
     Represents an entry in the admin navigation.
 
     :param key: Unique identifier used to store reference in an OrderedDict.
     :param name: Display name, usually a translation string.
     :param view_name: Name of the view, used generate the URL.
     :param active_list: list of urls that we select active for this element
     """
 
     def __init__(self, key, name, view_name, active_list=None):
         self.key = key
         self.name = name
         self.view_name = view_name
         self._active_list = active_list or []
 
     def generate_url(self, request):
         return request.route_path(self.view_name)
 
     def get_localized_name(self, request):
         return request.translate(self.name)
 
     @property
     def active_list(self):
         active_list = [self.key]
         if self._active_list:
             active_list = self._active_list
         return active_list
 
 
 @implementer(IAdminNavigationRegistry)
 class NavigationRegistry(object):
 
     _base_entries = [
         NavEntry('global', _('Global'),
                  'admin_settings_global'),
         NavEntry('vcs', _('VCS'),
                  'admin_settings_vcs'),
         NavEntry('visual', _('Visual'),
                  'admin_settings_visual'),
         NavEntry('mapping', _('Remap and Rescan'),
                  'admin_settings_mapping'),
         NavEntry('issuetracker', _('Issue Tracker'),
                  'admin_settings_issuetracker'),
         NavEntry('email', _('Email'),
                  'admin_settings_email'),
         NavEntry('hooks', _('Hooks'),
                  'admin_settings_hooks'),
         NavEntry('search', _('Full Text Search'),
                  'admin_settings_search'),
         NavEntry('integrations', _('Integrations'),
                  'global_integrations_home'),
         NavEntry('system', _('System Info'),
                  'admin_settings_system'),
+        NavEntry('exceptions', _('Exceptions Tracker'),
+                 'admin_settings_exception_tracker',
+                 active_list=['exceptions', 'exceptions_browse']),
         NavEntry('process_management', _('Processes'),
                  'admin_settings_process_management'),
         NavEntry('sessions', _('User Sessions'),
                  'admin_settings_sessions'),
         NavEntry('open_source', _('Open Source Licenses'),
                  'admin_settings_open_source'),
         NavEntry('automation', _('Automation'),
                  'admin_settings_automation')
     ]
 
     _labs_entry = NavEntry('labs', _('Labs'),
                            'admin_settings_labs')
 
     def __init__(self, labs_active=False):
         self._registered_entries = collections.OrderedDict()
         for item in self.__class__._base_entries:
             self._registered_entries[item.key] = item
 
         if labs_active:
             self.add_entry(self._labs_entry)
 
     def add_entry(self, entry):
         self._registered_entries[entry.key] = entry
 
     def get_navlist(self, request):
         navlist = [NavListEntry(i.key, i.get_localized_name(request),
                                 i.generate_url(request), i.active_list)
                    for i in self._registered_entries.values()]
         return navlist
 
 
 def navigation_registry(request, registry=None):
     """
     Helper that returns the admin navigation registry.
     """
     pyramid_registry = registry or request.registry
     nav_registry = pyramid_registry.queryUtility(IAdminNavigationRegistry)
     return nav_registry
 
 
 def navigation_list(request):
     """
     Helper that returns the admin navigation as list of NavListEntry objects.
     """
     return navigation_registry(request).get_navlist(request)
 
 
 def includeme(config):
     # Create admin navigation registry and add it to the pyramid registry.
     settings = config.get_settings()
     labs_active = str2bool(settings.get('labs_settings_active', False))
     navigation_registry = NavigationRegistry(labs_active=labs_active)
     config.registry.registerUtility(navigation_registry)
  No newline at end of file

rhodecode/config/middleware.py

@@ -1,510 +1,522 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
+import sys
 import logging
 import traceback
 import collections
 import tempfile
 
 from paste.gzipper import make_gzip_middleware
 from pyramid.wsgi import wsgiapp
 from pyramid.authorization import ACLAuthorizationPolicy
 from pyramid.config import Configurator
 from pyramid.settings import asbool, aslist
 from pyramid.httpexceptions import (
     HTTPException, HTTPError, HTTPInternalServerError, HTTPFound, HTTPNotFound)
 from pyramid.events import ApplicationCreated
 from pyramid.renderers import render_to_response
 
 from rhodecode.model import meta
 from rhodecode.config import patches
 from rhodecode.config import utils as config_utils
 from rhodecode.config.environment import load_pyramid_environment
 
 from rhodecode.lib.middleware.vcs import VCSMiddleware
 from rhodecode.lib.request import Request
 from rhodecode.lib.vcs import VCSCommunicationError
 from rhodecode.lib.exceptions import VCSServerUnavailable
 from rhodecode.lib.middleware.appenlight import wrap_in_appenlight_if_enabled
 from rhodecode.lib.middleware.https_fixup import HttpsFixup
 from rhodecode.lib.celerylib.loader import configure_celery
 from rhodecode.lib.plugins.utils import register_rhodecode_plugin
 from rhodecode.lib.utils2 import aslist as rhodecode_aslist, AttributeDict
+from rhodecode.lib.exc_tracking import store_exception
 from rhodecode.subscribers import (
     scan_repositories_if_enabled, write_js_routes_if_enabled,
     write_metadata_if_needed, inject_app_settings)
 
 
 log = logging.getLogger(__name__)
 
 
 def is_http_error(response):
     # error which should have traceback
     return response.status_code > 499
 
 
 def make_pyramid_app(global_config, **settings):
     """
     Constructs the WSGI application based on Pyramid.
 
     Specials:
 
     * The application can also be integrated like a plugin via the call to
       `includeme`. This is accompanied with the other utility functions which
       are called. Changing this should be done with great care to not break
       cases when these fragments are assembled from another place.
 
     """
 
     # Allows to use format style "{ENV_NAME}" placeholders in the configuration. It
     # will be replaced by the value of the environment variable "NAME" in this case.
     environ = {
         'ENV_{}'.format(key): value for key, value in os.environ.items()}
 
     global_config = _substitute_values(global_config, environ)
     settings = _substitute_values(settings, environ)
 
     sanitize_settings_and_apply_defaults(settings)
 
     config = Configurator(settings=settings)
 
     # Apply compatibility patches
     patches.inspect_getargspec()
 
     load_pyramid_environment(global_config, settings)
 
     # Static file view comes first
     includeme_first(config)
 
     includeme(config)
 
     pyramid_app = config.make_wsgi_app()
     pyramid_app = wrap_app_in_wsgi_middlewares(pyramid_app, config)
     pyramid_app.config = config
 
     config.configure_celery(global_config['__file__'])
     # creating the app uses a connection - return it after we are done
     meta.Session.remove()
 
     log.info('Pyramid app %s created and configured.', pyramid_app)
     return pyramid_app
 
 
 def not_found_view(request):
     """
     This creates the view which should be registered as not-found-view to
     pyramid.
     """
 
     if not getattr(request, 'vcs_call', None):
         # handle like regular case with our error_handler
         return error_handler(HTTPNotFound(), request)
 
     # handle not found view as a vcs call
     settings = request.registry.settings
     ae_client = getattr(request, 'ae_client', None)
     vcs_app = VCSMiddleware(
         HTTPNotFound(), request.registry, settings,
         appenlight_client=ae_client)
 
     return wsgiapp(vcs_app)(None, request)
 
 
 def error_handler(exception, request):
     import rhodecode
     from rhodecode.lib import helpers
 
     rhodecode_title = rhodecode.CONFIG.get('rhodecode_title') or 'RhodeCode'
 
     base_response = HTTPInternalServerError()
     # prefer original exception for the response since it may have headers set
     if isinstance(exception, HTTPException):
         base_response = exception
     elif isinstance(exception, VCSCommunicationError):
         base_response = VCSServerUnavailable()
 
     if is_http_error(base_response):
         log.exception(
             'error occurred handling this request for path: %s', request.path)
 
     error_explanation = base_response.explanation or str(base_response)
     if base_response.status_code == 404:
         error_explanation += " Or you don't have permission to access it."
     c = AttributeDict()
     c.error_message = base_response.status
     c.error_explanation = error_explanation
     c.visual = AttributeDict()
 
     c.visual.rhodecode_support_url = (
         request.registry.settings.get('rhodecode_support_url') or
         request.route_url('rhodecode_support')
     )
     c.redirect_time = 0
     c.rhodecode_name = rhodecode_title
     if not c.rhodecode_name:
         c.rhodecode_name = 'Rhodecode'
 
     c.causes = []
     if is_http_error(base_response):
         c.causes.append('Server is overloaded.')
         c.causes.append('Server database connection is lost.')
         c.causes.append('Server expected unhandled error.')
 
     if hasattr(base_response, 'causes'):
         c.causes = base_response.causes
 
     c.messages = helpers.flash.pop_messages(request=request)
-    c.traceback = traceback.format_exc()
+
+    exc_info = sys.exc_info()
+    c.exception_id = id(exc_info)
+    c.show_exception_id = isinstance(base_response, VCSServerUnavailable) \
+                          or base_response.status_code > 499
+    c.exception_id_url = request.route_url(
+        'admin_settings_exception_tracker_show', exception_id=c.exception_id)
+
+    if c.show_exception_id:
+        store_exception(c.exception_id, exc_info)
+
     response = render_to_response(
         '/errors/error_document.mako', {'c': c, 'h': helpers}, request=request,
         response=base_response)
 
     return response
 
 
 def includeme_first(config):
     # redirect automatic browser favicon.ico requests to correct place
     def favicon_redirect(context, request):
         return HTTPFound(
             request.static_path('rhodecode:public/images/favicon.ico'))
 
     config.add_view(favicon_redirect, route_name='favicon')
     config.add_route('favicon', '/favicon.ico')
 
     def robots_redirect(context, request):
         return HTTPFound(
             request.static_path('rhodecode:public/robots.txt'))
 
     config.add_view(robots_redirect, route_name='robots')
     config.add_route('robots', '/robots.txt')
 
     config.add_static_view(
         '_static/deform', 'deform:static')
     config.add_static_view(
         '_static/rhodecode', path='rhodecode:public', cache_max_age=3600 * 24)
 
 
 def includeme(config):
     settings = config.registry.settings
     config.set_request_factory(Request)
 
     # plugin information
     config.registry.rhodecode_plugins = collections.OrderedDict()
 
     config.add_directive(
         'register_rhodecode_plugin', register_rhodecode_plugin)
 
     config.add_directive('configure_celery', configure_celery)
 
     if asbool(settings.get('appenlight', 'false')):
         config.include('appenlight_client.ext.pyramid_tween')
 
     # Includes which are required. The application would fail without them.
     config.include('pyramid_mako')
     config.include('pyramid_beaker')
     config.include('rhodecode.lib.caches')
     config.include('rhodecode.lib.rc_cache')
 
     config.include('rhodecode.authentication')
     config.include('rhodecode.integrations')
 
     # apps
     config.include('rhodecode.apps._base')
     config.include('rhodecode.apps.ops')
 
     config.include('rhodecode.apps.admin')
     config.include('rhodecode.apps.channelstream')
     config.include('rhodecode.apps.login')
     config.include('rhodecode.apps.home')
     config.include('rhodecode.apps.journal')
     config.include('rhodecode.apps.repository')
     config.include('rhodecode.apps.repo_group')
     config.include('rhodecode.apps.user_group')
     config.include('rhodecode.apps.search')
     config.include('rhodecode.apps.user_profile')
     config.include('rhodecode.apps.user_group_profile')
     config.include('rhodecode.apps.my_account')
     config.include('rhodecode.apps.svn_support')
     config.include('rhodecode.apps.ssh_support')
     config.include('rhodecode.apps.gist')
 
     config.include('rhodecode.apps.debug_style')
     config.include('rhodecode.tweens')
     config.include('rhodecode.api')
 
     config.add_route(
         'rhodecode_support', 'https://rhodecode.com/help/', static=True)
 
     config.add_translation_dirs('rhodecode:i18n/')
     settings['default_locale_name'] = settings.get('lang', 'en')
 
     # Add subscribers.
     config.add_subscriber(inject_app_settings, ApplicationCreated)
     config.add_subscriber(scan_repositories_if_enabled, ApplicationCreated)
     config.add_subscriber(write_metadata_if_needed, ApplicationCreated)
     config.add_subscriber(write_js_routes_if_enabled, ApplicationCreated)
 
     # events
     # TODO(marcink): this should be done when pyramid migration is finished
     # config.add_subscriber(
     #     'rhodecode.integrations.integrations_event_handler',
     #     'rhodecode.events.RhodecodeEvent')
 
     # request custom methods
     config.add_request_method(
         'rhodecode.lib.partial_renderer.get_partial_renderer',
         'get_partial_renderer')
 
     # Set the authorization policy.
     authz_policy = ACLAuthorizationPolicy()
     config.set_authorization_policy(authz_policy)
 
     # Set the default renderer for HTML templates to mako.
     config.add_mako_renderer('.html')
 
     config.add_renderer(
         name='json_ext',
         factory='rhodecode.lib.ext_json_renderer.pyramid_ext_json')
 
     # include RhodeCode plugins
     includes = aslist(settings.get('rhodecode.includes', []))
     for inc in includes:
         config.include(inc)
 
     # custom not found view, if our pyramid app doesn't know how to handle
     # the request pass it to potential VCS handling ap
     config.add_notfound_view(not_found_view)
     if not settings.get('debugtoolbar.enabled', False):
         # disabled debugtoolbar handle all exceptions via the error_handlers
         config.add_view(error_handler, context=Exception)
 
     # all errors including 403/404/50X
     config.add_view(error_handler, context=HTTPError)
 
 
 def wrap_app_in_wsgi_middlewares(pyramid_app, config):
     """
     Apply outer WSGI middlewares around the application.
     """
     settings = config.registry.settings
 
     # enable https redirects based on HTTP_X_URL_SCHEME set by proxy
     pyramid_app = HttpsFixup(pyramid_app, settings)
 
     pyramid_app, _ae_client = wrap_in_appenlight_if_enabled(
         pyramid_app, settings)
     config.registry.ae_client = _ae_client
 
     if settings['gzip_responses']:
         pyramid_app = make_gzip_middleware(
             pyramid_app, settings, compress_level=1)
 
     # this should be the outer most middleware in the wsgi stack since
     # middleware like Routes make database calls
     def pyramid_app_with_cleanup(environ, start_response):
         try:
             return pyramid_app(environ, start_response)
         finally:
             # Dispose current database session and rollback uncommitted
             # transactions.
             meta.Session.remove()
 
             # In a single threaded mode server, on non sqlite db we should have
             # '0 Current Checked out connections' at the end of a request,
             # if not, then something, somewhere is leaving a connection open
             pool = meta.Base.metadata.bind.engine.pool
             log.debug('sa pool status: %s', pool.status())
 
     return pyramid_app_with_cleanup
 
 
 def sanitize_settings_and_apply_defaults(settings):
     """
     Applies settings defaults and does all type conversion.
 
     We would move all settings parsing and preparation into this place, so that
     we have only one place left which deals with this part. The remaining parts
     of the application would start to rely fully on well prepared settings.
 
     This piece would later be split up per topic to avoid a big fat monster
     function.
     """
 
     settings.setdefault('rhodecode.edition', 'Community Edition')
 
     if 'mako.default_filters' not in settings:
         # set custom default filters if we don't have it defined
         settings['mako.imports'] = 'from rhodecode.lib.base import h_filter'
         settings['mako.default_filters'] = 'h_filter'
 
     if 'mako.directories' not in settings:
         mako_directories = settings.setdefault('mako.directories', [
             # Base templates of the original application
             'rhodecode:templates',
         ])
         log.debug(
             "Using the following Mako template directories: %s",
             mako_directories)
 
     # Default includes, possible to change as a user
     pyramid_includes = settings.setdefault('pyramid.includes', [
         'rhodecode.lib.middleware.request_wrapper',
     ])
     log.debug(
         "Using the following pyramid.includes: %s",
         pyramid_includes)
 
     # TODO: johbo: Re-think this, usually the call to config.include
     # should allow to pass in a prefix.
     settings.setdefault('rhodecode.api.url', '/_admin/api')
 
     # Sanitize generic settings.
     _list_setting(settings, 'default_encoding', 'UTF-8')
     _bool_setting(settings, 'is_test', 'false')
     _bool_setting(settings, 'gzip_responses', 'false')
 
     # Call split out functions that sanitize settings for each topic.
     _sanitize_appenlight_settings(settings)
     _sanitize_vcs_settings(settings)
     _sanitize_cache_settings(settings)
 
     # configure instance id
     config_utils.set_instance_id(settings)
 
     return settings
 
 
 def _sanitize_appenlight_settings(settings):
     _bool_setting(settings, 'appenlight', 'false')
 
 
 def _sanitize_vcs_settings(settings):
     """
     Applies settings defaults and does type conversion for all VCS related
     settings.
     """
     _string_setting(settings, 'vcs.svn.compatible_version', '')
     _string_setting(settings, 'git_rev_filter', '--all')
     _string_setting(settings, 'vcs.hooks.protocol', 'http')
     _string_setting(settings, 'vcs.hooks.host', '127.0.0.1')
     _string_setting(settings, 'vcs.scm_app_implementation', 'http')
     _string_setting(settings, 'vcs.server', '')
     _string_setting(settings, 'vcs.server.log_level', 'debug')
     _string_setting(settings, 'vcs.server.protocol', 'http')
     _bool_setting(settings, 'startup.import_repos', 'false')
     _bool_setting(settings, 'vcs.hooks.direct_calls', 'false')
     _bool_setting(settings, 'vcs.server.enable', 'true')
     _bool_setting(settings, 'vcs.start_server', 'false')
     _list_setting(settings, 'vcs.backends', 'hg, git, svn')
     _int_setting(settings, 'vcs.connection_timeout', 3600)
 
     # Support legacy values of vcs.scm_app_implementation. Legacy
     # configurations may use 'rhodecode.lib.middleware.utils.scm_app_http'
     # which is now mapped to 'http'.
     scm_app_impl = settings['vcs.scm_app_implementation']
     if scm_app_impl == 'rhodecode.lib.middleware.utils.scm_app_http':
         settings['vcs.scm_app_implementation'] = 'http'
 
 
 def _sanitize_cache_settings(settings):
     _string_setting(settings, 'cache_dir',
                     os.path.join(tempfile.gettempdir(), 'rc_cache'))
     # cache_perms
     _string_setting(
         settings,
         'rc_cache.cache_perms.backend',
         'dogpile.cache.rc.file_namespace')
     _int_setting(
         settings,
         'rc_cache.cache_perms.expiration_time',
         60)
     _string_setting(
         settings,
         'rc_cache.cache_perms.arguments.filename',
         os.path.join(tempfile.gettempdir(), 'rc_cache_1'))
 
     # cache_repo
     _string_setting(
         settings,
         'rc_cache.cache_repo.backend',
         'dogpile.cache.rc.file_namespace')
     _int_setting(
         settings,
         'rc_cache.cache_repo.expiration_time',
         60)
     _string_setting(
         settings,
         'rc_cache.cache_repo.arguments.filename',
         os.path.join(tempfile.gettempdir(), 'rc_cache_2'))
 
     # sql_cache_short
     _string_setting(
         settings,
         'rc_cache.sql_cache_short.backend',
         'dogpile.cache.rc.memory_lru')
     _int_setting(
         settings,
         'rc_cache.sql_cache_short.expiration_time',
         30)
     _int_setting(
         settings,
         'rc_cache.sql_cache_short.max_size',
         10000)
 
 
 def _int_setting(settings, name, default):
     settings[name] = int(settings.get(name, default))
 
 
 def _bool_setting(settings, name, default):
     input_val = settings.get(name, default)
     if isinstance(input_val, unicode):
         input_val = input_val.encode('utf8')
     settings[name] = asbool(input_val)
 
 
 def _list_setting(settings, name, default):
     raw_value = settings.get(name, default)
 
     old_separator = ','
     if old_separator in raw_value:
         # If we get a comma separated list, pass it to our own function.
         settings[name] = rhodecode_aslist(raw_value, sep=old_separator)
     else:
         # Otherwise we assume it uses pyramids space/newline separation.
         settings[name] = aslist(raw_value)
 
 
 def _string_setting(settings, name, default, lower=True):
     value = settings.get(name, default)
     if lower:
         value = value.lower()
     settings[name] = value
 
 
 def _substitute_values(mapping, substitutions):
     result = {
         # Note: Cannot use regular replacements, since they would clash
         # with the implementation of ConfigParser. Using "format" instead.
         key: value.format(**substitutions)
         for key, value in mapping.items()
     }
     return result

rhodecode/public/css/main-content.less

@@ -1,385 +1,392 b''
 
 // Contains the style definitions used for .main-content
 // elements which are mainly around the admin settings.
 
 
 // TODO: johbo: Integrate in a better way, this is for "main content" which
 // should not have a limit on the width.
 .main-content-full {
     clear: both;
 }
 
 
 .main-content {
     max-width: @maincontent-maxwidth;
 
     h3,
     // TODO: johbo: Change templates to use h3 instead of h4 here
     h4 {
         line-height: 1em;
     }
 
     // TODO: johbo: Check if we can do that on a global level
     table {
         th {
             padding: 0;
         }
         td.field{
                 .help-block{
                     margin-left: 0;
                 }
         }
     }
 
     // TODO: johbo: Tweak this into the general styling, for a full width
     // textarea
     .textarea-full {
         // 2x 10px padding and 2x 1px border
         margin-right: 22px;
     }
 
 }
 
 
 // TODO: johbo: duplicated, think about a mixins.less
 .block-left{
     float: left;
 }
 
 .form {
     .checkboxes {
         // TODO: johbo: Should be changed in .checkboxes already
         width: auto;
     }
 
     // TODO: johbo: some settings pages are broken and don't have the .buttons
     // inside the .fields, tweak those templates and remove this.
     .buttons {
         margin-top: @textmargin;
     }
 
     .help-block {
         display: block;
         margin-left: @label-width;
         &.pre-formatting {
             white-space: pre;
         }
     }
 
     .action_button {
         color: @grey4;
     }
 }
 
 .main-content-full-width {
     .main-content;
     width: 100%;
     min-width: 100%;
 }
 
+.main-content-auto-width {
+    .main-content;
+    width: auto;
+    min-width: 100%;
+    max-width: inherit;
+}
+
 .field {
     clear: left;
     margin-bottom: @padding;
 
 }
 
 .input-monospace {
     font-family: @font-family-monospace;
 }
 
 .fields {
 	label {
 		color: @grey2;
 	}
 
     .field {
         clear: right;
         margin-bottom: @textmargin;
         width: 100%;
 
         .label {
             float: left;
             margin-right: @form-vertical-margin;
             margin-top: 0;
             padding-top: @input-padding-px + @border-thickness-inputs;
             width: @label-width - @form-vertical-margin;
         }
         // used in forms for fields that show just text
         .label-text {
             .label;
             padding-top: 5px;
         }
         // Used to position content on the right side of a .label
         .content,
         .side-by-side-selector {
             padding-top: @input-padding-px + @input-border-thickness;
         }
 
         .checkboxes,
         .input,
         .select,
         .textarea,
         .content {
             float: none;
             margin-left: @label-width;
 
             .help-block {
                 margin-left: 0;
             }
         }
 
         .checkboxes,
         .input,
         .select {
             .help-block {
                 display: block;
             }
         }
 
         .checkboxes,
         .radios {
             // TODO: johbo: We get a 4px margin from the from-bootstrap,
             // compensating here to align well with labels on the left.
             padding-top: @input-padding-px + @input-border-thickness - 3px;
         }
 
         .checkbox,
         .radio {
             display: block;
             width: auto;
         }
 
         .checkbox + .checkbox {
             display: block;
         }
 
         .input,
         .select {
             .help-block,
             .info-block {
                 margin-top: @form-vertical-margin / 2;
             }
         }
 
         .input {
             .medium {
                 width: @fields-input-m;
             }
             .large {
                 width: @fields-input-l;
             }
 
             .text-as-placeholder {
                 padding-top: @input-padding-px + @border-thickness-inputs;
             }
         }
 
         // TODO: johbo: Try to find a better integration of this bit.
         // When using a select2 inside of a field, it should not have the
         // top margin.
         .select .drop-menu {
             margin-top: 0;
         }
 
         .textarea {
             float: none;
 
             textarea {
                 // TODO: johbo: From somewhere we get a clear which does
                 // more harm than good here.
                 clear: none;
             }
 
             .CodeMirror {
                // TODO: johbo: Tweak to position the .help-block nicer,
                // figure out how to apply for .text-block instead.
                 margin-bottom: 10px;
             }
 
             // TODO: johbo: Check if we can remove the grey background on
             // the global level and remove this if possible.
             .help-block {
                 background: transparent;
                 padding: 0;
             }
         }
 
         &.tag_patterns,
         &.branch_patterns {
 
             input {
                 max-width: 430px;
             }
         }
     }
 
     .field-sm {
         .label {
             padding-top: @input-padding-px / 2 + @input-border-thickness;
         }
         .checkboxes,
         .radios {
             // TODO: johbo: We get a 4px margin from the from-bootstrap,
             // compensating here to align well with labels on the left.
             padding-top: @input-padding-px / 2 + @input-border-thickness - 3px;
         }
     }
 
     .field.customhooks {
         .label {
             padding-top: 0;
         }
         .input-wrapper {
             padding-right: 25px;
 
             input {
                 width: 100%;
             }
         }
         .input {
             padding-right: 25px;
         }
     }
 
     .buttons {
         // TODO: johbo: define variable for this value.
         // Note that this should be 40px but since most elements add some
         // space in the bottom, we are with 20 closer to 40.
         margin-top: 20px;
 		clear: both;
         margin-bottom: @padding;
     }
 
     .desc{
         margin-right: @textmargin;
     }
 
     input,
     .drop-menu {
         margin-right: @padding/3;
     }
 
 }
 
 .form-vertical .fields .field {
 
     .label {
         float: none;
         width: auto;
     }
 
     .checkboxes,
     .input,
     .select,
     .textarea {
         margin-left: 0;
     }
 
     // TODO: johbo: had to tweak the width here to make it big enough for
     // the license.
     .textarea.editor {
         max-width: none;
     }
 
     .textarea.large textarea {
         min-height: 200px;
     }
 
     .help-block {
         margin-left: 0;
     }
 }
 
 
 
 
 .main-content {
     .block-left;
 
     .section {
         margin-bottom: @space;
     }
 
 
     // Table aligning same way as forms in admin section, e.g.
     // python packages table
     table.formalign {
         float: left;
         width: auto;
 
         .label {
             width: @label-width;
         }
 
     }
 
 
     table.issuetracker {
 
         color: @text-color;
 
         .issue-tracker-example {
             color: @grey4;
         }
     }
 
     .side-by-side-selector{
         .left-group,
         .middle-group,
         .right-group{
             float: left;
         }
 
         .left-group,
         .right-group{
             width: 45%;
             text-align: center;
 
             label{
                 width: 100%;
                 text-align: left;
             }
 
             select{
                 width: 100%;
                 background: none;
                 border-color: @border-highlight-color;
                 color: @text-color;
                 font-family: @text-light;
                 font-size: @basefontsize;
                 color: @grey1;
                 padding: @textmargin/2;
             }
 
             select:after{
                 content: "";
             }
 
         }
 
         .middle-group{
             width: 10%;
             text-align: center;
             padding-top: 4em;
             i {
                 font-size: 18px;
                 cursor: pointer;
                 line-height: 2em;
             }
         }
 
     }
 
     .permissions_boxes{
         label, .label{
             margin-right: @textmargin/2;
         }
     }
 
     .radios{
         label{
             margin-right: @textmargin;
         }
     }
 }
 

rhodecode/templates/admin/settings/settings.mako

@@ -1,53 +1,53 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.mako"/>
 
 <%def name="title()">
     ${_('Settings administration')}
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.route_path('admin_home'))}
     &raquo;
     ${_('Settings')}
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='admin')}
 </%def>
 
 <%def name="side_bar_nav()">
   % for navitem in c.navlist:
     <li class="${'active' if c.active in navitem.active_list else ''}">
       <a href="${navitem.url}">${navitem.name}</a>
     </li>
   % endfor
 </%def>
 
 <%def name="main_content()">
   <%include file="/admin/settings/settings_${c.active}.mako"/>
 </%def>
 
 <%def name="main()">
 <div class="box">
     <div class="title">
         ${self.breadcrumbs()}
     </div>
 
     ##main
     <div class='sidebar-col-wrapper'>
       <div class="sidebar">
           <ul class="nav nav-pills nav-stacked">
             ${self.side_bar_nav()}
           </ul>
       </div>
 
-      <div class="main-content-full-width">
+      <div class="main-content-auto-width">
         ${self.main_content()}
       </div>
     </div>
 </div>
 
 </%def>
  No newline at end of file

rhodecode/templates/errors/error_document.mako

@@ -1,76 +1,84 b''
 ## -*- coding: utf-8 -*-
 <!DOCTYPE html>
 <html xmlns="http://www.w3.org/1999/xhtml">
     <head>
         <title>Error - ${c.error_message}</title>
         <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
         <meta name="robots" content="index, nofollow"/>
         <link rel="icon" href="${h.asset('images/favicon.ico')}" sizes="16x16 32x32" type="image/png" />
 
         <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
         %if c.redirect_time:
             <meta http-equiv="refresh" content="${c.redirect_time}; url=${c.url_redirect}"/>
         %endif
 
         <link rel="stylesheet" type="text/css" href="${h.asset('css/style.css', ver=c.rhodecode_version_hash)}" media="screen"/>
         <!--[if IE]>
             <link rel="stylesheet" type="text/css" href="${h.asset('css/ie.css')}" media="screen"/>
         <![endif]-->
         <style>body { background:#eeeeee; }</style>
         <script type="text/javascript">
             // register templateContext to pass template variables to JS
             var templateContext = {timeago: {}};
         </script>
         <script type="text/javascript" src="${h.asset('js/scripts.js', ver=c.rhodecode_version_hash)}"></script>
     </head>
     <body>
 
         <div class="wrapper error_page">
             <div class="sidebar">
                 <a href="${h.route_path('home')}"><img class="error-page-logo" src="${h.asset('images/RhodeCode_Logo_Black.png')}" alt="RhodeCode"/></a>
             </div>
             <div class="main-content">
                 <h1>
                     <span class="error-branding">
                         ${h.branding(c.rhodecode_name)}
                     </span><br/>
                     ${c.error_message} | <span class="error_message">${c.error_explanation}</span>
                 </h1>
                 % if c.messages:
                     % for message in c.messages:
                         <div class="alert alert-${message.category}">${message}</div>
                     % endfor
                 % endif    
                 %if c.redirect_time:
                     <p>${_('You will be redirected to %s in %s seconds') % (c.redirect_module,c.redirect_time)}</p>
                 %endif
                 <div class="inner-column">
                     <h4>Possible Causes</h4>
                     <ul>
                     % if c.causes:
                         %for cause in c.causes:
                             <li>${cause}</li>
                         %endfor
                     %else:
                         <li>The resource may have been deleted.</li>
                         <li>You may not have access to this repository.</li>
                         <li>The link may be incorrect.</li>
                     %endif
                     </ul>
                 </div>
                 <div class="inner-column">
                     <h4>Support</h4>
-                    <p>For support, go to <a href="${c.visual.rhodecode_support_url}" target="_blank">${_('Support')}</a>.
+                    <p>For help and support, go to the <a href="${c.visual.rhodecode_support_url}" target="_blank">${_('Support Page')}</a>.
                        It may be useful to include your log file; see the log file locations <a href="${h.route_url('enterprise_log_file_locations')}">here</a>.
                     </p>
+                    % if c.show_exception_id:
+                    <p>
+                        Super Admin can see detailed traceback information from this exception by checking the below Exception ID.
+                        Please include the below link for further details of this exception.
+
+                        Exception ID: <a href="${c.exception_id_url}">${c.exception_id}</a>
+                    </p>
+                    % endif
                 </div>
                 <div class="inner-column">
                     <h4>Documentation</h4>
                     <p>For more information, see <a href="${h.route_url('enterprise_docs')}">docs.rhodecode.com</a>.</p>
                 </div>
             </div>
         </div>
 
     </body>
 
 </html>