def __call__(self, error):
        template_fname = self.data_browser.error_template

        if isinstance(error, PermissionDenied):
            permissions = []
            for idx, need in enumerate(error.args[0].needs):
                permissions.append(str(need))
            err_msg = _(
                u'this operation needs the following permissions: %(permissions)s, contact administrator to grant '
                u'them!',
                permissions=";".join(permissions))
        elif isinstance(error, ValidationError):
            err_msg = ",".join("%s: %s" % (k, v) for k, v in error.args[0].items())
        elif isinstance(error, NotFound):
            err_msg = _("Sorry, object doesn't exist!")
        else:
            # we need to log the crime scene
            # note, this is the last line of defence, we must resolve it here!
            traceback = get_current_traceback(skip=1, show_hidden_frames=False,
                                              ignore_system_exceptions=True)
            self.data_browser.app.logger.error("%s %s" % (request.method, request.url))
            self.data_browser.app.logger.error(traceback.plaintext)
            err_msg = _(u'Internal error "%(err)s", please contact us!', err=str(error))

        return render_template(template_fname, hint_message=err_msg, error=error,
                               back_url=request.args.get("url", "/"))

    def _post_data(self, context):
        """POST data to the the Exceptional API. If DEBUG is True then data is
        sent to ``EXCEPTIONAL_DEBUG_URL`` if it has been defined. If TESTING is
        true, error data is stored in the global ``flask.g.exceptional`` variable.
        
        :param context: The current application context.
        """
        traceback = tbtools.get_current_traceback()
        error_data = json.dumps({
            "application_environment": self.__get_application_data(context.app),
            "client": context.app.extensions["exceptional"],
            "request": self.__get_request_data(context.app, context.request, context.session),
            "exception": self.__get_exception_data(traceback)
        })
        
        if context.app.testing:
            g.exceptional = error_data
        
        if self.url:
            request = Request(self.url)
            request.add_header("Content-Type", "application/json")
            
            if context.app.debug:
                data = error_data
            else:
                request.add_header("Content-Encoding", "deflate")
                data = compress(error_data, 1)
            
            try:
                urlopen(request, data)
            except URLError:
                message = "Unable to connect to {0}. See \
http://status.getexceptional.com for details. Error data:\n{1}".format(self.url, error_data)
                self.app.logger.warning(message, exc_info=True)

    def debug_application(self, environ, start_response):
        app_iter = None
        try:
            app_iter = self.app(environ, start_response)
            for item in app_iter:
                yield item

            if hasattr(app_iter, 'close'):
                app_iter.close()
        except:
            if hasattr(app_iter, 'close'):
                app_iter.close()
            traceback = get_current_traceback(skip=1, show_hidden_frames=self.show_hidden_frames, ignore_system_exceptions=True)
            for frame in traceback.frames:
                self.frames[frame.id] = frame

            self.tracebacks[traceback.id] = traceback
            try:
                start_response('500 INTERNAL SERVER ERROR', [('Content-Type', 'text/html; charset=utf-8')])
            except:
                environ['wsgi.errors'].write('Debugging middleware caught exception in streamed response at a point where response headers were already sent.\n')
            else:
                yield traceback.render_full(evalex=self.evalex).encode('utf-8', 'replace')

            traceback.log(environ['wsgi.errors'])

 def errorlog(exception):
     """ We want to log exception information to file for later investigation """
     traceback = get_current_traceback(ignore_system_exceptions=True, show_hidden_frames=True)
     log.error(traceback.plaintext)
     last = traceback.frames[-1]
     now = datetime.datetime.now().replace(microsecond=0)
     return render_template("error.html", now=now, name=os.path.basename(last.filename), line=last.lineno, exception=exception)

def send_exception(subject):
    """Send Python exception tracebacks via email to the ADMINS list.

    Use the same HTML styling as Flask tracebacks in debug web servers.

    This function must be called while the exception is happening. It picks up the raised exception with sys.exc_info().

    Positional arguments:
    subject -- subject line of the email (to be prepended by 'Application Error: ').
    """
    # Generate and modify html.
    tb = tbtools.get_current_traceback()  # Get exception information.
    with _override_html():
        html = tb.render_full().encode('utf-8', 'replace')
    html = html.replace('<blockquote>', '<blockquote style="margin: 1em 0 0; padding: 0;">')
    subject = 'Application Error: {}'.format(subject)

    # Apply throttle.
    md5 = hashlib.md5('{}{}'.format(subject, html)).hexdigest()
    seconds = int(current_app.config['MAIL_EXCEPTION_THROTTLE'])
    lock = redis.lock(EMAIL_THROTTLE.format(md5=md5), timeout=seconds)
    have_lock = lock.acquire(blocking=False)
    if not have_lock:
        current_app.logger.debug('Suppressing email: {}'.format(subject))
        return

    # Send email.
    msg = Message(subject=subject, recipients=current_app.config['ADMINS'], html=html)
    mail.send(msg)

 def get_current_traceback(self):
     "Get the current Python traceback, keeping stack frames in debug app."
     traceback = get_current_traceback()
     for frame in traceback.frames:
         self.debug_app.frames[frame.id] = frame
     self.debug_app.tracebacks[traceback.id] = traceback
     return traceback

def json_response(f, *args, **kwargs):
    try:
        response = f(*args, **kwargs)

    except HTTPException as e:
        data = {'error': str(e),
                'description': e.description}
        return jsonify(data), e.code

    except Exception as e:
        app.logger.error('Exception during json request: %r', e)
        # Werkzeug sends the response and then logs, which is fiddly
        from werkzeug.debug.tbtools import get_current_traceback
        traceback = get_current_traceback(ignore_system_exceptions=True)
        app.logger.info('Traceback %s', traceback.plaintext)

        data = {'error': e.__class__.__name__,
                'description': str(e)}
        return jsonify(data), 500

    else:
        if isinstance(response, (app.response_class, BaseResponse)):
            return response

        return jsonify(response), 200

        def wrapper(request):
            try:
                response = func(request)
            except Exception as e:
                tb = get_current_traceback()
                return responses.InternalServerError(render_function(tb), headers={"Content-type": content_type})

            return response

    def render_exception(self):
        traceback = get_current_traceback()

        for frame in traceback.frames:
            self.debugger.frames[frame.id] = frame
        self.debugger.tracebacks[traceback.id] = traceback

        return traceback.render_full(evalex=True,
                                     secret=self.debugger.secret)

 def handle_request(self, req):
     with self.request_context(req):
         try:
             response = self.full_dispatch_request()
         except Exception, e:
             self.log_exception(e)
             try:
                 response = self.make_response(self.handle_exception(e))
             except:
                 tb = tbtools.get_current_traceback(skip=1)
                 response = Response(tb.render_summary(), headers={'Content-Type' : 'text/html'})

    def error(error):
        if isinstance(error, SQLAlchemyError):
            from lite_mms.database import db

            db.session.rollback()
        from werkzeug.debug.tbtools import get_current_traceback

        traceback = get_current_traceback(skip=1, show_hidden_frames=False,
                                          ignore_system_exceptions=True)
        app.logger.error("%s %s" % (request.method, request.url))
        app.logger.error(traceback.plaintext)
        sender_email(traceback)
        return redirect(url_for("error", errors=u"%s %s时，系统异常" % (request.method, request.url),
                                detail=traceback.render_summary(), url=request.args.get("url", "/")))

 def error(error):
     if isinstance(error, SQLAlchemyError):
         from cloud_dashing.database import db
         db.session.rollback()
     from werkzeug.debug.tbtools import get_current_traceback
     traceback = get_current_traceback(skip=1, show_hidden_frames=False,
                                       ignore_system_exceptions=True)
     app.logger.error("%s %s" % (request.method, request.url))
     app.logger.error(traceback.plaintext)
     sender_email(traceback)
     return render_template("error.html",
                            error=_("Failed to %(method)s %(url)s",
                                    method=request.method, url=request.url),
                            detail=traceback.render_summary(),
                            back_url=request.args.get("__back_url__", "/"))

    def error(error):
        if isinstance(error, SQLAlchemyError):
            from litefac.database import db

            db.session.rollback()
        from werkzeug.debug.tbtools import get_current_traceback

        traceback = get_current_traceback(skip=1, show_hidden_frames=False,
                                          ignore_system_exceptions=True)
        app.logger.error("%s %s" % (request.method, request.url))
        app.logger.error(traceback.plaintext)
        sender_email(traceback)
        return render_template("error.html", msg=u"%s %s时，系统异常" % (request.method, request.url),
                               detail=traceback.render_summary(),
                               back_url=request.args.get("back_url", "/"),
                               nav_bar=nav_bar, titlename=u"错误"), 403

    def debug_application(self, environ, start_response):
        """Run the application and conserve the traceback frames."""
        app_iter = None
        try:
            app_iter = self.app(environ, start_response)
            for item in app_iter:
                yield item
            if hasattr(app_iter, 'close'):
                app_iter.close()
        except Exception:
            if hasattr(app_iter, 'close'):
                app_iter.close()
            traceback = get_current_traceback(
                skip=1, show_hidden_frames=self.show_hidden_frames,
                ignore_system_exceptions=True)
            for frame in traceback.frames:
                self.frames[frame.id] = frame
            self.tracebacks[traceback.id] = traceback

            try:
                start_response('500 INTERNAL SERVER ERROR', [
                    ('Content-Type', 'text/html; charset=utf-8'),
                    # Disable Chrome's XSS protection, the debug
                    # output can cause false-positives.
                    ('X-XSS-Protection', '0'),
                ])
            except Exception:
                # if we end up here there has been output but an error
                # occurred.  in that situation we can do nothing fancy any
                # more, better log something into the error log and fall
                # back gracefully.
                environ['wsgi.errors'].write(
                    'Debugging middleware caught exception in streamed '
                    'response at a point where response headers were already '
                    'sent.\n')
            else:
                is_trusted = bool(self.check_pin_trust(environ))
                yield traceback.render_full(evalex=self.evalex,
                                            evalex_trusted=is_trusted,
                                            secret=self.secret) \
                    .encode('utf-8', 'replace')

            traceback.log(environ['wsgi.errors'])

    def debug_application(self, environ, start_response):
        """Run the application and conserve the traceback frames."""
        app_iter = None
        try:
            app_iter = self.app(environ, start_response)
            for item in app_iter:
                yield item
            if hasattr(app_iter, 'close'):
                app_iter.close()
        except Exception:
            if hasattr(app_iter, 'close'):
                app_iter.close()
            traceback = get_current_traceback(skip=1, show_hidden_frames=
                                              self.show_hidden_frames,
                                              ignore_system_exceptions=True)
            for frame in traceback.frames:
                self.frames[frame.id] = frame
            self.tracebacks[traceback.id] = traceback

            try:
                start_response('500 INTERNAL SERVER ERROR', [
                    ('Content-Type', 'text/html; charset=utf-8')
                ])
            except Exception:
                # if we end up here there has been output but an error
                # occurred.  in that situation we can do nothing fancy any
                # more, better log something into the error log and fall
                # back gracefully.
                environ['wsgi.errors'].write(
                    'Debugging middleware caught exception in streamed '
                    'response at a point where response headers were already '
                    'sent.\n')
            else:
                yield traceback.render_full(evalex=self.evalex,
                                            lodgeit_url=self.lodgeit_url,
                                            secret=self.secret,
                                            pid=self.multiprocess_support and getpid() or '') \
                               .encode('utf-8', 'replace')

            traceback.log(environ['wsgi.errors'])

    def wrapper(request, *args, **kwargs):
        try:
            return func(request, *args, **kwargs)

        except api_exceptions.NotFound as ex:
            return responses.NotFound(**_render_error(ex))

        except api_exceptions.Forbidden as ex:
            return responses.Forbidden(**_render_error(ex))

        except api_exceptions.BadRequest as ex:
            return responses.BadRequest(**_render_error(ex))

        except Exception as ex:
            if settings.DEBUG == False:
                return responses.InternalServerError(**_render_error(ex, "Internal error: {}".format(str(ex))))
            else:
                from werkzeug.debug.tbtools import get_current_traceback
                traceback = get_current_traceback()
                return responses.InternalServerError(
                    traceback.plaintext,
                    headers={"Content-type": "text/plain"}
                )

                if not headers_sent:
                    write('')
            finally:
                if hasattr(application_iter, 'close'):
                    application_iter.close()
                application_iter = None

        try:
            execute(app)
        except (socket.error, socket.timeout), e:
            self.connection_dropped(e, environ)
        except:
            if self.server.passthrough_errors:
                raise
            from werkzeug.debug.tbtools import get_current_traceback
            traceback = get_current_traceback(ignore_system_exceptions=True)
            try:
                # if we haven't yet sent the headers but they are set
                # we roll back to be able to set them again.
                if not headers_sent:
                    del headers_set[:]
                execute(InternalServerError())
            except:
                pass
            self.server.log('error', 'Error on request:\n%s',
                            traceback.plaintext)

    def handle(self):
        """Handles a request ignoring dropped connections."""
        try:
            return BaseHTTPRequestHandler.handle(self)

    def run_wsgi(self):
        app = self.server.app
        environ = self.make_environ()
        headers_set = []
        headers_sent = []

        def write(data):
            if not headers_sent:
                status, response_headers = headers_sent[:] = headers_set
                code, msg = status.split(None, 1)
                self.send_response(int(code), msg)
                header_keys = set()
                for key, value in response_headers:
                    self.send_header(key, value)
                    key = key.lower()
                    header_keys.add(key)

                if 'content-length' not in header_keys:
                    self.close_connection = True
                    self.send_header('Connection', 'close')
                if 'server' not in header_keys:
                    self.send_header('Server', self.version_string())
                if 'date' not in header_keys:
                    self.send_header('Date', self.date_time_string())
                self.end_headers()
            self.wfile.write(data)
            self.wfile.flush()

        def start_response(status, response_headers, exc_info = None):
            if exc_info:
                try:
                    if headers_sent:
                        raise exc_info[0], exc_info[1], exc_info[2]
                finally:
                    exc_info = None

            elif headers_set:
                raise AssertionError('Headers already set')
            headers_set[:] = [status, response_headers]
            return write

        def execute(app):
            application_iter = app(environ, start_response)
            try:
                for data in application_iter:
                    write(data)

                if not headers_sent:
                    write('')
            finally:
                if hasattr(application_iter, 'close'):
                    application_iter.close()
                application_iter = None

        try:
            execute(app)
        except (socket.error, socket.timeout) as e:
            self.connection_dropped(e, environ)
        except:
            if self.server.passthrough_errors:
                raise
            from werkzeug.debug.tbtools import get_current_traceback
            traceback = get_current_traceback(ignore_system_exceptions=True)
            try:
                if not headers_sent:
                    del headers_set[:]
                execute(InternalServerError())
            except:
                pass

            self.server.log('error', 'Error on request:\n%s', traceback.plaintext)

 def _store_traceback(self):
     traceback = get_current_traceback(skip=1,
                                       show_hidden_frames=False,
                                       ignore_system_exceptions=True)
     self.tracebacks[traceback.id] = traceback
     return "/debug/{}".format(traceback.id)

def internal_error(exception):
    app.logger.exception(exception)
    tb = tbtools.get_current_traceback()
    print "traceback", tb
    return flask.render_template('500.html', exception=exception, traceback=tb.plaintext)