################################################################################
# RhodeCode - Pylons environment configuration #
# #
# The %(here)s variable will be replaced with the parent directory of this file#
[DEFAULT]
debug = true
pdebug = false
## Uncomment and replace with the address which should receive ##
## any error reports after application crash ##
## Additionally those settings will be used by RhodeCode mailing system ##
#email_to = admin@localhost
#error_email_from = paste_error@localhost
#app_email_from = rhodecode-noreply@localhost
#error_message =
#email_prefix = [RhodeCode]
#smtp_server = mail.server.com
#smtp_username =
#smtp_password =
#smtp_port =
#smtp_use_tls = false
#smtp_use_ssl = true
# Specify available auth parameters here (e.g. LOGIN PLAIN CRAM-MD5, etc.)
#smtp_auth =
[server:main]
##nr of threads to spawn
#threadpool_workers = 5
##max request before thread respawn
#threadpool_max_requests = 10
##option to use threads of process
#use_threadpool = true
#use = egg:Paste#http
use = egg:waitress#main
host = 0.0.0.0
port = 5000
[filter:proxy-prefix]
# prefix middleware for rc
use = egg:PasteDeploy#prefix
prefix = /<your-prefix>
[app:main]
use = egg:rhodecode
#filter-with = proxy-prefix
full_stack = true
static_files = true
# Optional Languages
# en, fr, ja, pt_BR, zh_CN, zh_TW
lang = en
cache_dir = %(here)s/data
index_dir = %(here)s/data/index
app_instance_uuid = rc-develop
cut_off_limit = 256000
force_https = false
commit_parse_limit = 25
use_gravatar = true
## alternative_gravatar_url allows you to use your own avatar server application
## the following parts of the URL will be replaced
## {email} user email
## {md5email} md5 hash of the user email (like at gravatar.com)
## {size} size of the image that is expected from the server application
## {scheme} http/https from RhodeCode server
## {netloc} network location from RhodeCode server
#alternative_gravatar_url = http://myavatarserver.com/getbyemail/{email}/{size}
#alternative_gravatar_url = http://myavatarserver.com/getbymd5/{md5email}?s={size}
container_auth_enabled = false
proxypass_auth_enabled = false
default_encoding = utf8
## overwrite schema of clone url
## available vars:
## scheme - http/https
## user - current user
## pass - password
## netloc - network location
## path - usually repo_name
#clone_uri = {scheme}://{user}{pass}{netloc}{path}
## issue tracking mapping for commits messages
## comment out issue_pat, issue_server, issue_prefix to enable
## pattern to get the issues from commit messages
## default one used here is #<numbers> with a regex passive group for `#`
## {id} will be all groups matched from this pattern
issue_pat = (?:\s*#)(\d+)
## server url to the issue, each {id} will be replaced with match
## fetched from the regex and {repo} is replaced with full repository name
## including groups {repo_name} is replaced with just name of repo
issue_server_link = https://myissueserver.com/{repo}/issue/{id}
## prefix to add to link to indicate it's an url
## #314 will be replaced by <issue_prefix><id>
issue_prefix = #
## issue_pat, issue_server_link, issue_prefix can have suffixes to specify
## multiple patterns, to other issues server, wiki or others
## below an example how to create a wiki pattern
# #wiki-some-id -> https://mywiki.com/some-id
#issue_pat_wiki = (?:wiki-)(.+)
#issue_server_link_wiki = https://mywiki.com/{id}
#issue_prefix_wiki = WIKI-
## instance-id prefix
## a prefix key for this instance used for cache invalidation when running
## multiple instances of rhodecode, make sure it's globally unique for
## all running rhodecode instances. Leave empty if you don't use it
instance_id =
## alternative return HTTP header for failed authentication. Default HTTP
## response is 401 HTTPUnauthorized. Currently HG clients have troubles with
## handling that. Set this variable to 403 to return HTTPForbidden
auth_ret_code =
####################################
### CELERY CONFIG ####
use_celery = false
broker.host = localhost
broker.vhost = rabbitmqhost
broker.port = 5672
broker.user = rabbitmq
broker.password = qweqwe
celery.imports = rhodecode.lib.celerylib.tasks
celery.result.backend = amqp
celery.result.dburi = amqp://
celery.result.serialier = json
#celery.send.task.error.emails = true
#celery.amqp.task.result.expires = 18000
celeryd.concurrency = 2
#celeryd.log.file = celeryd.log
celeryd.log.level = debug
celeryd.max.tasks.per.child = 1
#tasks will never be sent to the queue, but executed locally instead.
celery.always.eager = false
### BEAKER CACHE ####
beaker.cache.data_dir=%(here)s/data/cache/data
beaker.cache.lock_dir=%(here)s/data/cache/lock
beaker.cache.regions=super_short_term,short_term,long_term,sql_cache_short,sql_cache_med,sql_cache_long
beaker.cache.super_short_term.type=memory
beaker.cache.super_short_term.expire=10
beaker.cache.super_short_term.key_length = 256
beaker.cache.short_term.type=memory
beaker.cache.short_term.expire=60
beaker.cache.short_term.key_length = 256
beaker.cache.long_term.type=memory
beaker.cache.long_term.expire=36000
beaker.cache.long_term.key_length = 256
beaker.cache.sql_cache_short.type=memory
beaker.cache.sql_cache_short.expire=10
beaker.cache.sql_cache_short.key_length = 256
beaker.cache.sql_cache_med.type=memory
beaker.cache.sql_cache_med.expire=360
beaker.cache.sql_cache_med.key_length = 256
beaker.cache.sql_cache_long.type=file
beaker.cache.sql_cache_long.expire=3600
beaker.cache.sql_cache_long.key_length = 256
### BEAKER SESSION ####
## Type of storage used for the session, current types are
## dbm, file, memcached, database, and memory.
## The storage uses the Container API
## that is also used by the cache system.
## db session ##
#beaker.session.type = ext:database
#beaker.session.sa.url = postgresql://postgres:qwe@localhost/rhodecode
#beaker.session.table_name = db_session
## encrypted cookie client side session, good for many instances ##
#beaker.session.type = cookie
## file based cookies (default) ##
#beaker.session.type = file
beaker.session.key = rhodecode
## secure cookie requires AES python libraries ##
#beaker.session.encrypt_key = g654dcno0-9873jhgfreyu
#beaker.session.validate_key = 9712sds2212c--zxc123
## sets session as invalid if it haven't been accessed for given amount of time
beaker.session.timeout = 2592000
beaker.session.httponly = true
#beaker.session.cookie_path = /<your-prefix>
## uncomment for https secure cookie ##
beaker.session.secure = false
## auto save the session to not to use .save() ##
beaker.session.auto = False
## default cookie expiration time in seconds `true` expire at browser close ##
#beaker.session.cookie_expires = 3600
############################
## ERROR HANDLING SYSTEMS ##
####################
### [errormator] ###
# Errormator is tailored to work with RhodeCode, see
# http://errormator.com for details how to obtain an account
# you must install python package `errormator_client` to make it work
# errormator enabled
errormator = true
errormator.server_url = https://api.errormator.com
errormator.api_key = YOUR_API_KEY
# TWEAK AMOUNT OF INFO SENT HERE
# enables 404 error logging (default False)
errormator.report_404 = false
# time in seconds after request is considered being slow (default 1)
errormator.slow_request_time = 1
# record slow requests in application
# (needs to be enabled for slow datastore recording and time tracking)
errormator.slow_requests = true
# enable hooking to application loggers
# errormator.logging = true
# minimum log level for log capture
# errormator.logging.level = WARNING
# send logs only from erroneous/slow requests
# (saves API quota for intensive logging)
errormator.logging_on_error = false
# list of additonal keywords that should be grabbed from environ object
# can be string with comma separated list of words in lowercase
# (by default client will always send following info:
# 'REMOTE_USER', 'REMOTE_ADDR', 'SERVER_NAME', 'CONTENT_TYPE' + all keys that
# start with HTTP* this list be extended with additional keywords here
errormator.environ_keys_whitelist =
# list of keywords that should be blanked from request object
# (by default client will always blank keys that contain following words
# 'password', 'passwd', 'pwd', 'auth_tkt', 'secret', 'csrf'
# this list be extended with additional keywords set here
errormator.request_keys_blacklist =
# list of namespaces that should be ignores when gathering log entries
# can be string with comma separated list of namespaces
# (by default the client ignores own entries: errormator_client.client)
errormator.log_namespace_blacklist =
#
# YOU SHOULD NOT NEED TO TWEAK THIS
# leave server_name empty for auto discovery
# errormator.server_name =
# connection timeout when communicating with API
# errormator.timeout = 10
# reraise exceptions when wsgi catches exception
# errormator.reraise_exceptions = true
# enables 500 error logging
errormator.report_errors = true
# how often send data to mothership Errormator (default 5s)
errormator.buffer_flush_interval = 5
# send all data after request is finished - handy for crons or other voliatile applications
errormator.force_send = false
# custom filter callable to override sensitive data filtering
# errormator.filter_callable = foo.bar.baz:callable_name
################
### [sentry] ###
# sentry is a alternative open source error aggregator
# you must install python packages `sentry` and `raven` to enable
sentry.dsn = YOUR_DNS
sentry.servers =
sentry.name =
sentry.key =
sentry.public_key =
sentry.secret_key =
sentry.project =
sentry.site =
sentry.include_paths =
sentry.exclude_paths =
## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT* ##
## Debug mode will enable the interactive debugging tool, allowing ANYONE to ##
## execute malicious code after an exception is raised. ##
#set debug = false
##################################
### LOGVIEW CONFIG ###
logview.sqlalchemy = #faa
logview.pylons.templating = #bfb
logview.pylons.util = #eee
#########################################################
### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG ###
#sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode.db
sqlalchemy.db1.url = postgresql://postgres:qwe@localhost/rhodecode
sqlalchemy.db1.echo = false
sqlalchemy.db1.pool_recycle = 3600
sqlalchemy.db1.convert_unicode = true
################################
### LOGGING CONFIGURATION ####
[loggers]
keys = root, routes, rhodecode, sqlalchemy, beaker, templates, whoosh_indexer
[handlers]
keys = console, console_sql
[formatters]
keys = generic, color_formatter, color_formatter_sql
#############
## LOGGERS ##
[logger_root]
level = NOTSET
handlers = console
[logger_routes]
level = DEBUG
handlers =
qualname = routes.middleware
# "level = DEBUG" logs the route matched and routing variables.
propagate = 1
[logger_beaker]
qualname = beaker.container
[logger_templates]
level = INFO
qualname = pylons.templating
[logger_rhodecode]
qualname = rhodecode
[logger_sqlalchemy]
handlers = console_sql
qualname = sqlalchemy.engine
propagate = 0
[logger_whoosh_indexer]
qualname = whoosh_indexer
##############
## HANDLERS ##
[handler_console]
class = StreamHandler
args = (sys.stderr,)
formatter = color_formatter
[handler_console_sql]
formatter = color_formatter_sql
## FORMATTERS ##
[formatter_generic]
format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
datefmt = %Y-%m-%d %H:%M:%S
[formatter_color_formatter]
class=rhodecode.lib.colored_formatter.ColorFormatter
format= %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
[formatter_color_formatter_sql]
class=rhodecode.lib.colored_formatter.ColorFormatterSql
host = 127.0.0.1
port = 8001
app_instance_uuid = rc-production
commit_parse_limit = 50
set debug = false
formatter = generic
level = WARN
app_instance_uuid = ${app_instance_uuid}
# SQLITE [default]
sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode.db
# POSTGRESQL
# sqlalchemy.db1.url = postgresql://user:pass@localhost/rhodecode
# MySQL
# sqlalchemy.db1.url = mysql://user:pass@localhost/rhodecode
# see sqlalchemy docs for others
"""Pylons middleware initialization"""
from beaker.middleware import SessionMiddleware
from routes.middleware import RoutesMiddleware
from paste.cascade import Cascade
from paste.registry import RegistryManager
from paste.urlparser import StaticURLParser
from paste.deploy.converters import asbool
from paste.gzipper import make_gzip_middleware
from pylons.middleware import ErrorHandler, StatusCodeRedirect
from pylons.wsgiapp import PylonsApp
from rhodecode.lib.middleware.simplehg import SimpleHg
from rhodecode.lib.middleware.simplegit import SimpleGit
from rhodecode.lib.middleware.https_fixup import HttpsFixup
from rhodecode.config.environment import load_environment
def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
"""Create a Pylons WSGI application and return it
``global_conf``
The inherited configuration for this application. Normally from
the [DEFAULT] section of the Paste ini file.
``full_stack``
Whether or not this application provides a full WSGI stack (by
default, meaning it handles its own exceptions and errors).
Disable full_stack when this application is "managed" by
another WSGI middleware.
``app_conf``
The application's local configuration. Normally specified in
the [app:<name>] section of the Paste ini file (where <name>
defaults to main).
"""
# Configure the Pylons environment
config = load_environment(global_conf, app_conf)
# The Pylons WSGI app
app = PylonsApp(config=config)
# Routing/Session/Cache Middleware
app = RoutesMiddleware(app, config['routes.map'])
app = SessionMiddleware(app, config)
# CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)
if asbool(config['pdebug']):
from rhodecode.lib.profiler import ProfilingMiddleware
app = ProfilingMiddleware(app)
if asbool(full_stack):
from rhodecode.lib.middleware.sentry import Sentry
from rhodecode.lib.middleware.errormator import Errormator
if Errormator:
app = Errormator(app, config)
elif Sentry:
app = Sentry(app, config)
# Handle Python exceptions
app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
# we want our low level middleware to get to the request ASAP. We don't
# need any pylons stack middleware in them
app = SimpleHg(app, config)
app = SimpleGit(app, config)
# Display error documents for 401, 403, 404 status codes (and
# 500 when debug is disabled)
if asbool(config['debug']):
app = StatusCodeRedirect(app)
else:
app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
#enable https redirets based on HTTP_X_URL_SCHEME set by proxy
app = HttpsFixup(app, config)
# Establish the Registry for this application
app = RegistryManager(app)
if asbool(static_files):
# Serve static files
static_app = StaticURLParser(config['pylons.paths']['static_files'])
app = Cascade([static_app, app])
app = make_gzip_middleware(app, global_conf, compress_level=1)
app.config = config
return app
new file 100644
# -*- coding: utf-8 -*-
rhodecode.lib.middleware.errormator
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
middleware to handle errormator publishing of errors
:created_on: October 18, 2012
:author: marcink
:copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>
:license: GPLv3, see COPYING for more details.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# 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 General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
try:
from errormator_client import make_errormator_middleware
except ImportError:
Errormator = None
Errormator = make_errormator_middleware
\ No newline at end of file
rhodecode.lib.middleware.sentry
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
middleware to handle sentry/raven publishing of errors
:created_on: September 18, 2012
from raven.base import Client
from raven.contrib.pylons import list_from_setting
from raven.middleware import Sentry as Middleware
Sentry = None
class Sentry(Middleware):
def __init__(self, app, config, client_cls=Client):
client = client_cls(
dsn=config.get('sentry.dsn'),
servers=list_from_setting(config, 'sentry.servers'),
name=config.get('sentry.name'),
key=config.get('sentry.key'),
public_key=config.get('sentry.public_key'),
secret_key=config.get('sentry.secret_key'),
project=config.get('sentry.project'),
site=config.get('sentry.site'),
include_paths=list_from_setting(config, 'sentry.include_paths'),
exclude_paths=list_from_setting(config, 'sentry.exclude_paths'),
)
super(Sentry, self).__init__(app, client)
Status change: