def get_release_name(base_dir, server_env): release_dir = base_dir.split('/')[-1] if re.match('\d{4}-\d{2}-\d{2}_\d{2}.\d{2}', release_dir): release = "{}-{}-deploy".format(release_dir, server_env) else: release = fetch_git_sha(base_dir) return release
def RAVEN_CONFIG(self): import raven return { 'dsn': str(super().SENTRY_DSN), 'release': raven.fetch_git_sha(super().BASE_DIR), }
def setup(cls): super(Base, cls).setup() cls.RAVEN_CONFIG = { 'dsn': cls.SENTRY_DSN, 'release': raven.fetch_git_sha(cls.PROJECT_PATH), }
def get_odoo_commit(odoo_dir): '''Attempts to get Odoo git commit from :param:`odoo_dir`.''' if not odoo_dir: return try: return fetch_git_sha(odoo_dir) except InvalidGitRepository: pass
def on_configure(self): if settings.PDB_ENABLE_SENTRY: # ignore for coverage client = raven.Client(settings.PDB_SENTRY_DSN) client.release = raven.fetch_git_sha(os.path.dirname(os.pardir)) # register a custom filter to filter out duplicate logs register_logger_signal(client) # hook into the Celery error handler register_signal(client)
def RAVEN_CONFIG(self): if not hasattr(self, 'RAVEN_SECRET_KEY'): return {} return { 'dsn': 'https://{public_key}:{secret_key}@app.getsentry.com/{project_id}'.format( public_key=self.RAVEN_PUBLIC_KEY, secret_key=self.RAVEN_SECRET_KEY, project_id=self.RAVEN_PROJECT_ID ), 'release': raven.fetch_git_sha(self.TOP_DIR), }
def get_release(): config = get_raven_config() if config.project_dist: try: return get_distribution(config.project_dist).version except DistributionNotFound: LOG.error('The distribution "{}" could not be found.'.format(config.project_dist)) return None if config.buildout_root: try: return fetch_git_sha(config.buildout_root) except InvalidGitRepository: LOG.error("The path {} does not exist or is not" " a git repository".format(config.buildout_root)) return None return None
def create_update_sentry_release(): from settingshelper import get_release_name from raven import fetch_git_sha release = get_release_name(settings.BASE_DIR, settings.SERVER_ENVIRONMENT) headers = {'Authorization': 'Bearer {}'.format(settings.SENTRY_API_KEY), } payload = { 'version': release, 'refs': [{ 'repository': 'dimagi/commcare-hq', 'commit': fetch_git_sha(settings.BASE_DIR) }], 'projects': ['commcarehq'] } releases_url = 'https://sentry.io/api/0/organizations/dimagi/releases/' response = requests.post(releases_url, headers=headers, json=payload) if response.status_code == 208: # already created so update payload.pop('version') requests.put('{}{}/'.format(releases_url, release), headers=headers, json=payload)
def init(args): if args.log_config: log_config = json.load(args.log_config) logging.config.dictConfig(log_config) else: logging.basicConfig(level=args.log_level, format='%(asctime)s %(levelname)8s [%(name)s] %(message)s') log.info('--- Starting ---') git_sha = raven.fetch_git_sha(os.path.dirname(os.path.dirname(__file__))) log.info('Git commit: %s', git_sha) # Log errors to Sentry client = raven.Client( # dsn=os.environ.get('SENTRY_DSN'), include_paths=['fewerror'], release=git_sha, ignore_exceptions=[ KeyboardInterrupt, ], ) handler = SentryHandler(client) handler.setLevel(logging.WARNING) raven.conf.setup_logging(handler)
} MIDDLEWARE_CLASSES = tuple([pair[1] for pair in sorted(MIDDLEWARE_GLOBAL + MIDDLEWARE_LOCAL)]) # set tempdir so that we don't have to worry about collision if not getattr(tempfile, 'alreadytwiddled', False): # Python appears to run this multiple times tempdir = os.path.join(tempfile.gettempdir(), "esptmp__" + CACHE_PREFIX) if not os.path.exists(tempdir): os.makedirs(tempdir) tempfile.tempdir = tempdir tempfile.alreadytwiddled = True # change csrf cookie name from default to prevent collisions with misbehaving sites # that set a cookie on the top-level domain # NOTE: don't change this value; it's hard coded into various JavaScript files CSRF_COOKIE_NAME = 'esp_csrftoken' if SENTRY_DSN: # If SENTRY_DSN is set, send errors to Sentry via the Raven exception # handler. Note that our exception middleware (i.e., ESPErrorMiddleware) # will remain enabled and will receive exceptions before Raven does. import raven INSTALLED_APPS += ( 'raven.contrib.django.raven_compat', ) RAVEN_CONFIG = { 'dsn': SENTRY_DSN, 'release': raven.fetch_git_sha(os.path.join(PROJECT_ROOT, '..')), }
'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', ] if secrets.get('raven_dsn', ''): import raven INSTALLED_APPS.append('raven.contrib.django.raven_compat') RAVEN_CONFIG = { 'dsn': secrets.get('raven_dsn', ''), 'release': raven.fetch_git_sha(REPO_DIR), } MIDDLEWARE_CLASSES = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.auth.middleware.SessionAuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', ] REST_FRAMEWORK = { 'DEFAULT_RENDERER_CLASSES': (
COMPRESS_CSS_FILTERS = [ "compressor.filters.css_default.CssAbsoluteFilter", "compressor.filters.cssmin.CSSMinFilter", ] COMPRESS_CSS_HASHING_METHOD = None # Celery settings CELERY_BROKER_URL = "redis://localhost:6379/0" CELERY_RESULT_BACKEND = "django-db" # Meta tags info META_TITLE = "Welcome to official blog of Alex Manti." META_DESCRIPTION = "Official blog of Alex Manti. My music, photos and info about me." # Instagram settings INSTAGRAM_USER_ID = "" INSTAGRAM_CLIENT_ID = "" INSTAGRAM_ACCESS_TOKEN = "" INSTAGRAM_CLIENT_SECRET = "" # Sentry integration ROOT_DIR = os.path.dirname((os.path.dirname(PROJECT_DIR))) RAVEN_CONFIG = {"dsn": "", "release": raven.fetch_git_sha(ROOT_DIR)}
# Number of days used to consider a register staled DAYS_TO_STALE_REGISTER = config("DAYS_TO_STALE_REGISTER", default=90, cast=int) SOCIAL_AUTH_FACEBOOK_KEY = config("SOCIAL_AUTH_FACEBOOK_KEY", default="") SOCIAL_AUTH_FACEBOOK_SECRET = config("SOCIAL_AUTH_FACEBOOK_SECRET", default="") SOCIAL_AUTH_TWITTER_KEY = config("SOCIAL_AUTH_TWITTER_KEY", default="") SOCIAL_AUTH_TWITTER_SECRET = config("SOCIAL_AUTH_TWITTER_SECRET", default="") FACEBOOK_SHARE_GRAPH_API_VERSION = config("FACEBOOK_SHARE_GRAPH_API_VERSION", default="3.1") FACEBOOK_SHARE_URL = "https://www.facebook.com/sharer.php?u=https://cademeubicho.com/pets/{}/" TWITTER_SHARE_URL = "https://twitter.com/share?url=https://cademeubicho.com/pets/{}/" REPO_ROOT = config("REPO_ROOT", default=os.path.abspath(os.pardir)) RAVEN_CONFIG = {"dsn": config("RAVEN_DSN", default=""), "release": raven.fetch_git_sha(REPO_ROOT)} SENDGRID_API_KEY = config("SENDGRID_API_KEY", default="") DEFAULT_FROM_EMAIL = config("EMAIL_HOST_USER", default="*****@*****.**") CORS_ORIGIN_ALLOW_ALL = True CORS_URLS_REGEX = r"^/api/.*$" REST_FRAMEWORK = { "DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.LimitOffsetPagination", "PAGE_SIZE": 20, } GOOGLE_API_KEY = config("GOOGLE_API_KEY", default="") HOTJAR_TRACKING_KEY = config("HOTJAR_TRACKING_KEY", default="")
EMAIL_HOST_PASSWORD = '******'passwordstore', 'privacymail/admin/send-pass' )}}' EMAIL_SUBJECT_PREFIX = '[PMail] ' # For debugging you may use the console backend # EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend' # Profiling SILKY_PYTHON_PROFILER = True # Authentication SILKY_AUTHENTICATION = True # User must login SILKY_AUTHORISATION = True # User must have permissions RAVEN_CONFIG = { 'dsn': '{{ lookup('passwordstore', 'privacymail/raven-dsn') }}', # If you are using git, you can also automatically configure the # release based on the git info. 'release': raven.fetch_git_sha("{{ install_path }}"), 'transport': RequestsHTTPTransport, } LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'root': { 'level': 'WARNING', 'handlers': ['sentry'], }, 'formatters': { 'verbose': { 'format': ('%(levelname)s %(asctime)s %(module)s %(process)d ' '%(thread)d %(message)s') },
COMPRESS_OFFLINE = True # media settings MEDIA_ROOT = os.path.join(BASE_DIR, 'media') MEDIA_URL = '/media/' LOGIN_URL = '/' # sentry.io if not DEBUG: RAVEN_CONFIG = { 'dsn': JSON_DATA['sentry_dsn'], # If you are using git, you can also automatically configure the # release based on the git info. 'release': raven.fetch_git_sha(os.path.dirname(os.pardir)), } # cache CACHEOPS_REDIS = { 'host': 'localhost', # redis-server is on same machine 'port': 6379, # default redis port 'db': 14, # SELECT non-default redis database } CACHEOPS = { # Automatically cache any User.objects.get() calls for 15 minutes # This includes request.user or post.author access, # where Post.author is a foreign key to auth.User 'auth.user': {'ops': 'all', 'timeout': 60*60*24*30}, '*.*': {'ops': 'all', 'timeout': 60*60*24*2}, # enable cache for all model for 2 days
addr='*****@*****.**', ) # Securiy related settings SECURE_HSTS_SECONDS = 2592000 SECURE_BROWSER_XSS_FILTER = True SESSION_COOKIE_SECURE = True CSRF_COOKIE_SECURE = True CSRF_COOKIE_HTTPONLY = True SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https') X_FRAME_OPTIONS = 'DENY' # Setting for sentry INSTALLED_APPS += ( 'raven.contrib.django.raven_compat', ) import raven # noqa RAVEN_CONFIG = { 'dsn': env('DSN_URL'), 'release': raven.fetch_git_sha(os.path.dirname(BASE_DIR)), } GA_TRACK_ID = env('GA_TRACK_ID', default=None) GTM_TRACK_ID = env('GTM_TRACK_ID', default=None) DJANGO_Q_DEBUG = False
# https://django-extensions.readthedocs.io/en/latest/shell_plus.html SHELL_PLUS = 'ipython' REST_FRAMEWORK = { 'DEFAULT_AUTHENTICATION_CLASSES': ( 'rest_framework.authentication.SessionAuthentication', ), 'DEFAULT_PERMISSION_CLASSES': ( 'rest_framework.permissions.IsAuthenticated', ), 'DEFAULT_FILTER_BACKENDS': [ 'django_filters.rest_framework.DjangoFilterBackend' ], } try: RELEASE = raven.fetch_git_sha(BASE_DIR) except InvalidGitRepository: RELEASE = None RAVEN_CONFIG = { 'dsn': os.getenv('SENTRY_KEY'), 'release': RELEASE, 'environment': 'base', } RECAPTCHA_PUBLIC_KEY = os.getenv('RECAPTCHA_PUBLIC_KEY') RECAPTCHA_PRIVATE_KEY = os.getenv('RECAPTCHA_PRIVATE_KEY') CORS_ORIGIN_WHITELIST = []
'propagate': False, }, 'django.request': { 'handlers': ['file'], 'level': 'ERROR', 'propagate': False, }, } } CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': '127.0.0.1:11211', } } try: from .sentry_settings import DSN import raven INSTALLED_APPS.append( 'raven.contrib.django.raven_compat' ) RAVEN_CONFIG = { 'dsn': DSN, 'release': raven.fetch_git_sha(os.path.dirname(BASE_DIR)), } except ImportError: pass
from .debug import DEBUG import os import raven from .base import BASE_DIR if not DEBUG: # sentry post url settings(https://docs.sentry.io/clients/python/integrations/django/) RAVEN_CONFIG = { 'dsn': os.getenv('DSN'), 'release': raven.fetch_git_sha(os.path.abspath(BASE_DIR)), } # log format setting LOGGING = { 'version': 1, 'disable_existing_loggers': True, 'root': { 'level': 'WARNING', 'handlers': ['console', 'sentry'], }, 'formatters': { 'verbose': { 'format': '%(levelname)s %(asctime)s %(module)s ' '%(process)d %(thread)d %(message)s' }, }, 'handlers': { 'sentry': { 'level': 'ERROR', # To capture more than ERROR, change to WARNING, INFO, etc.
class CommunityProdSettings(CommunityBaseSettings): """Settings for local development""" SERVE_DOCS = ['private'] PYTHON_MEDIA = True PRODUCTION_DOMAIN = '{{ rtd_domain }}' USE_SUBDOMAIN = False PUBLIC_DOMAIN = '{{ PUBLIC_DOMAIN }}' PUBLIC_API_URL = '{{ PUBLIC_API_URL }}' GLOBAL_ANALYTICS_CODE = '{{ GLOBAL_ANALYTICS_CODE }}' PUBLIC_DOMAIN_USES_HTTPS = '{{ rtd_proto }}' == 'https' # default build versions RTD_LATEST = 'bozza' RTD_LATEST_VERBOSE_NAME = RTD_LATEST RTD_STABLE = 'stabile' RTD_STABLE_VERBOSE_NAME = RTD_STABLE RTD_LATEST_EN = 'draft' RTD_STABLE_EN = 'stable' # General settings DEBUG = {{ DEBUG }} TEMPLATE_DEBUG = False DOCS_BASE = os.environ.get('DOCS_BASE', CommunityBaseSettings.SITE_ROOT) MEDIA_ROOT = os.path.join(DOCS_BASE, 'media/') STATIC_ROOT = os.path.join(DOCS_BASE, 'media/static/') MEDIA_URL = '{{ MEDIA_URL }}' STATIC_URL = '{{ MEDIA_URL }}static/' ADMIN_MEDIA_PREFIX = MEDIA_URL + 'admin/' SECRET_KEY = '{{ SECRET_KEY }}' DEFAULT_FROM_EMAIL = '{{ DEFAULT_FROM_EMAIL }}' SESSION_COOKIE_DOMAIN = '{{ rtd_domain }}' TAGGIT_TAGS_FROM_STRING = 'readthedocs.docsitalia.utils.docsitalia_parse_tags' DOCROOT = os.path.join(DOCS_BASE, 'user_builds') UPLOAD_ROOT = os.path.join(DOCS_BASE, 'user_uploads') CNAME_ROOT = os.path.join(DOCS_BASE, 'cnames') LOGS_ROOT = os.path.join(DOCS_BASE, 'logs') PRODUCTION_ROOT = os.path.join(DOCS_BASE, 'prod_artifacts') PUBLIC_BASE = DOCS_BASE PRIVATE_BASE = DOCS_BASE @property def TEMPLATES(self): # noqa TEMPLATES = super().TEMPLATES TEMPLATE_OVERRIDES = os.path.join(super().TEMPLATE_ROOT, 'docsitalia', 'overrides') TEMPLATES[0]['DIRS'].insert(0, TEMPLATE_OVERRIDES) return TEMPLATES @property def INSTALLED_APPS(self): # noqa apps = super(CommunityProdSettings, self).INSTALLED_APPS # Insert our depends above RTD applications, after guaranteed third # party package apps.append('readthedocs.docsitalia') apps.append('dal', ) apps.append('dal_select2', ) {% if USE_CONVERTER %}apps.insert(apps.index('rest_framework'), 'docs_italia_convertitore_web'){% endif %} {% if SENTRY_DSN|string|length %}apps.insert(apps.index('rest_framework'), 'raven.contrib.django.raven_compat'){% endif %} return apps # Celery CACHES = dict( (cache_name, { 'BACKEND': 'redis_cache.RedisCache', 'LOCATION': '{host}:{port}'.format(**cache), 'OPTIONS': { 'DB': cache['db'], }, }) for (cache_name, cache) in _redis.items() if cache_name is not 'celery' ) BROKER_URL = 'redis://{{ rtd_redis_celery }}' CELERY_RESULT_BACKEND = 'redis://{{ rtd_redis_celery }}' # Docker DOCKER_SOCKET = 'tcp://{{ docker_main_ip }}:2375' DOCKER_ENABLE = {{ DOCKER_ENABLE }} DOCKER_IMAGE = '{{ docker_rtd_image }}' DOCKER_VERSION = '1.33' DOCKER_LIMITS = { 'memory': '999m', 'time': 3600, } {% if SENTRY_DSN|string|length %} import raven RAVEN_CONFIG = { 'dsn': '{{ SENTRY_DSN }}', 'release': raven.fetch_git_sha(CommunityBaseSettings.SITE_ROOT), 'environment': '{{ SENTRY_ENVIRONMENT }}' } {% endif %} # Haystack - we don't really use it. ES API is used instead HAYSTACK_CONNECTIONS = { 'default': { 'ENGINE': 'haystack.backends.simple_backend.SimpleEngine', }, } CELERY_ALWAYS_EAGER = False CELERY_HAYSTACK_DEFAULT_ALIAS = None CELERY_TASK_RESULT_EXPIRES = 7200 # Elastic Search ES_HOSTS = '{{ es_hosts }}'.split(',') ELASTICSEARCH_DSL = { 'default': { 'hosts': ES_HOSTS }, } # RTD settings # This goes together with FILE_SYNCER setting # eg: FILE_SINCER = 'readthedocs.builds.syncers.*' (likely RemoteSyncer) MULTIPLE_APP_SERVERS = '{{ app_hosts }}'.split(',') MULTIPLE_BUILD_SERVERS = '{{ worker_hosts }}'.split(',') SLUMBER_API_HOST = 'http://{{ api_host }}' SLUMBER_USERNAME = '******' SLUMBER_PASSWORD = '******' SYNC_USER = '******' #DOCROOT = '/var/build' ACCOUNT_EMAIL_VERIFICATION = 'mandatory' SESSION_ENGINE = 'django.contrib.sessions.backends.cache' SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https") REPO_LOCK_SECONDS = 300 DONT_HIT_DB = False # Override classes CLASS_OVERRIDES = { 'readthedocs.builds.syncers.Syncer': 'readthedocs.builds.syncers.LocalSyncer', 'readthedocs.core.resolver.Resolver': 'readthedocs.docsitalia.resolver.ItaliaResolver', 'readthedocs.oauth.services.GitHubService': 'readthedocs.docsitalia.oauth.services.github.DocsItaliaGithubService', } # Email if {{ USE_SMTP }}: EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend' EMAIL_USE_TLS = True EMAIL_HOST = '{{ EMAIL_HOST }}' EMAIL_HOST_USER = '******' EMAIL_HOST_PASSWORD = '******' else: EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend' # Social Auth GITHUB_APP_ID = '{{ GITHUB_APP_ID }}' GITHUB_API_SECRET = '{{ GITHUB_API_SECRET }}' SOCIALACCOUNT_PROVIDERS = { 'github': {'SCOPE': ['user:email', 'read:org', 'admin:repo_hook', 'repo:status']} } ACCOUNT_DEFAULT_HTTP_PROTOCOL = 'https' ADMINS = ( ('Test', 'test@{{ rtd_domain }}'), ) TIME_ZONE = 'Europe/Rome' LANGUAGE_CODE = 'it-it' CORS_ORIGIN_WHITELIST = ( '{{ rtd_domain }}:8000', )
# Prevent logging errors from the django shell. # Errors from other management commands will be still logged. if len(sys.argv) > 1 and sys.argv[1] in ["shell", "shell_plus"]: RAVEN_CONFIG["ignore_exceptions"] = ["*"] # There's a chooser to toggle between environments at the top right corner on sentry.io # Values are typically 'staging' or 'production' but can be set to anything else if needed. # dokku config:set mresponse SENTRY_ENVIRONMENT=staging # heroku config:set SENTRY_ENVIRONMENT=production if "SENTRY_ENVIRONMENT" in env: RAVEN_CONFIG["environment"] = env["SENTRY_ENVIRONMENT"] # We first assume that the Git repository is present and we can detect the # commit hash from it. try: RAVEN_CONFIG["release"] = raven.fetch_git_sha(BASE_DIR) except InvalidGitRepository: try: # But if it's not, we assume that the commit hash is available in # the GIT_REV environment variable. It's a default environment # variable used on Dokku: # http://dokku.viewdocs.io/dokku/deployment/methods/git/#configuring-the-git_rev-environment-variable RAVEN_CONFIG["release"] = env["GIT_REV"] except KeyError: # If there's no commit hash, we do not set a specific release. pass # Security configuration # This configuration is required to achieve good security rating. # You can test it using https://securityheaders.com/ # https://docs.djangoproject.com/en/stable/ref/middleware/#module-django.middleware.security
TIME_ZONE = "UTC" USE_I18N = True USE_L10N = True USE_TZ = True LOGLEVEL = "DEBUG" if DEBUG else "INFO" LOGGING = { "version": 1, "disable_existing_loggers": False, "formatters": {"simple": {"format": "[%(asctime)s] [%(levelname)s] %(message)s"}}, "filters": {"require_debug_true": {"()": "django.utils.log.RequireDebugTrue"}}, "handlers": {"console": {"class": "logging.StreamHandler", "formatter": "simple"}}, "loggers": { "actions": {"handlers": ["console"], "level": LOGLEVEL}, "capabilities": {"handlers": ["console"], "level": LOGLEVEL}, "hardware": {"handlers": ["console"], "level": LOGLEVEL}, "schedule": {"handlers": ["console"], "level": LOGLEVEL}, "scheduler": {"handlers": ["console"], "level": LOGLEVEL}, "sensor": {"handlers": ["console"], "level": LOGLEVEL}, "status": {"handlers": ["console"], "level": LOGLEVEL}, "tasks": {"handlers": ["console"], "level": LOGLEVEL}, }, } SENTRY_DSN = env("SENTRY_DSN", default="") if SENTRY_DSN: import raven RAVEN_CONFIG = {"dsn": SENTRY_DSN, "release": raven.fetch_git_sha(REPO_ROOT)}
ACCOUNT_DEFAULT_HTTP_PROTOCOL = 'https' ACCOUNT_USERNAME_MIN_LENGTH = 5 ACCOUNT_USERNAME_BLACKLIST = ['admin', 'owner', 'user'] ACCOUNT_USERNAME_REQUIRED = True ACCOUNT_PASSWORD_MIN_LENGTH = 6 ACCOUNT_LOGIN_ON_EMAIL_CONFIRMATION = True ACCOUNT_LOGIN_ON_PASSWORD_RESET = True ACCOUNT_SESSION_REMEMBER = True SOCIALACCOUNT_QUERY_EMAIL = ACCOUNT_EMAIL_REQUIRED SOCIALACCOUNT_PROVIDERS = {'google': { 'SCOPE': ['profile', 'email'], 'AUTH_PARAMS': {'access_type': 'online'} }} RAVEN_CONFIG = {'dsn': '', 'release': raven.fetch_git_sha(BASE_DIR)} ENTREZ_TERMS = ['chordoma', 'breast cancer', 'diabetes'] ENTREZ_MAX_COUNT = 10 NCBO_API_KEY = '5dbf6de8-fda5-4ef7-a3a8-bcea293f3715' STOP_WORDS = 'protein,gene,disease,disorder,syndrome,chromosome,receptor,cell,\ orphan,thumb,center,with,involved,image,type,known,encoded,this,both,\ human,second,near,observed,from,family,width,name,caption,state,\ structure,MEROPS,Pfam,domain,Symbol,SMART,crystal,analogue,\ protein family,SCOP,InterPro,EC number,Name,group,related,then,Some,\ form,http,abstract,content,liter,levels,enzyme,drugs,into,slow,\ intermediate,bound,Citation,when,down,After' POSTIVE_FLATTER = ['Bravo', 'Wow', 'Super', 'Terrific', 'Cool', 'Amazing', 'Superb', 'Brilliant', 'Fantastic', 'Fabulous', 'You\'re a Champion', 'Well done', 'You rock', 'Great job', 'Tip top', 'Good thinking', 'Keep it up', 'Way to go', 'Right on', 'Top stuff', 'Take a bow', 'Unreal', 'Impressed', 'Great stuff', 'Awesome', 'Nice going', 'Very Creative', 'Thank You', 'Beautiful', 'Very proud', 'Good for you', 'Give me five', 'You make me happy', 'A+', 'A++', 'AA+', 'Fab', 'Rad', 'A+++', 'AAA+', 'A-OK', 'Best', 'Cool', 'Deal', 'Fast', 'Fine', 'Item', 'Nice', 'Safe', 'Thx!', 'WOW!', 'Prime', 'Solid', 'Super', 'Sweet', 'Thanx', 'Whoa!', 'Groovy', 'Honest', 'Speedy', 'Superb', 'Sweeet', 'Thanks', 'Zowie!', 'Amazing', 'Awesome', 'Quality', 'Service', 'Sweeeet', 'Glorious', 'Stunning', 'Superior', 'The Best', 'The Bomb', 'Thrilled', 'Way Cool', 'Brilliant', 'Competent', 'Delighted', 'Excellent', 'Exquisite', 'Marvelous', 'Overjoyed', 'Satisfied', 'Thank You', 'Top Notch', 'Unrivaled', 'Wonderful', 'A Home Run', 'Astounding', 'Delightful', 'Impressive', 'Incredible', 'Super Cool', 'Super Fast', 'Supersonic', 'Astonishing', 'Fascinating', 'Interesting', 'Magnificent', 'No Problems', 'Outstanding', 'Splendorous', 'Trustworthy', 'Unsurpassed', 'Wicked Cool', 'Breathtaking', 'Looking Good', 'Overwhelming!', 'Unbelievable!', 'Awe Inspiring', 'Lickety Split', 'Splendiferous', 'Thanks A Ton!', 'Extremely Cool', 'Satisfied 100%', 'Extremely Happy', 'Great Condition', 'Above And Beyond', 'State Of The Art', 'Thanks A Million!', 'Unbelievably Cool', 'Expertly Described', 'Extremely Satisfied', 'Great Communication', 'Greatly Appreciated', 'Beyond My Wildest Dreams', 'Supercalifragilisticexpialidocious', 'Thank You! Thank You! Thank You!'] SUPPORT_FLATTER = ['You can do it', 'Nice Try', 'Don\'t give up', 'Every bit counts', 'Thank you', 'Keep going', 'You can do better than that']
# Port that the Notifications Server listens on #NOTIFICATIONS_SERVER_PORT = 7887 # Domain to use for serving IP to hostname mappings # using ./manage.py ipauth-dnsserver #IPAUTH_DNSSERVER_DOMAIN = 'oioioi.example.com' # Error reporting import raven RAVEN_CONFIG = { # Won't do anything with no dsn # tip: append ?timeout=5 to avoid dropouts during high reporting traffic 'dsn': '', # This should be a path to git repo 'release': raven.fetch_git_sha( os.path.join(os.path.dirname(oioioi.__file__), os.pardir)), } # Bonus to judging priority ang judging weight for each contest on this # OIOIOI instance. #OIOIOI_INSTANCE_PRIORITY_BONUS = 0 #OIOIOI_INSTANCE_WEIGHT_BONUS = 0 # If set to True, usercontests will become read-only: it will be impossible to # change, delete or submit to existing usercontests, as well as add new ones. # This operation is fully reversible. #ARCHIVE_USERCONTESTS = True
DAYS_TO_STALE_REGISTER = config('DAYS_TO_STALE_REGISTER', default=90, cast=int) SOCIAL_AUTH_FACEBOOK_KEY = config('SOCIAL_AUTH_FACEBOOK_KEY', default='') SOCIAL_AUTH_FACEBOOK_SECRET = config('SOCIAL_AUTH_FACEBOOK_SECRET', default='') SOCIAL_AUTH_TWITTER_KEY = config('SOCIAL_AUTH_TWITTER_KEY', default='') SOCIAL_AUTH_TWITTER_SECRET = config('SOCIAL_AUTH_TWITTER_SECRET', default='') FACEBOOK_SHARE_GRAPH_API_VERSION = config('FACEBOOK_SHARE_GRAPH_API_VERSION', default='3.1') FACEBOOK_SHARE_URL = 'https://www.facebook.com/sharer.php?u=https://cademeubicho.com/pets/{}/' TWITTER_SHARE_URL = 'https://twitter.com/share?url=https://cademeubicho.com/pets/{}/' REPO_ROOT = config('REPO_ROOT', default=os.path.abspath(os.pardir)) RAVEN_CONFIG = { 'dsn': config('RAVEN_DSN', default=''), 'release': raven.fetch_git_sha(REPO_ROOT), } SENDGRID_API_KEY = config('SENDGRID_API_KEY', default='') DEFAULT_FROM_EMAIL = config('EMAIL_HOST_USER', default='*****@*****.**') CORS_ORIGIN_ALLOW_ALL = True CORS_URLS_REGEX = r'^/api/.*$' REST_FRAMEWORK = { 'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination', 'PAGE_SIZE': 20 } GOOGLE_API_KEY = config('GOOGLE_API_KEY', default='') HOTJAR_TRACKING_KEY = config('HOTJAR_TRACKING_KEY', default='')
DEFAULT_FROM_EMAIL = "{{cookiecutter.project_name}} <noreply@{{cookiecutter.domain_name}}>" # https://docs.djangoproject.com/en/dev/ref/settings/#server-email SERVER_EMAIL = DEFAULT_FROM_EMAIL # https://docs.djangoproject.com/en/dev/ref/settings/#email-subject-prefix EMAIL_SUBJECT_PREFIX = default="[{{cookiecutter.project_name}}]" # SENTRY VALIDATION # ------------------------------------------------------------------------------ INSTALLED_APPS.append( 'raven.contrib.django.raven_compat', ) RAVEN_CONFIG = { 'dsn': '', # If you are using git, you can also automatically configure the # release based on the git info. 'release': raven.fetch_git_sha(BASE_DIR), } # LOGGING # ------------------------------------------------------------------------------ ROTATING_FILE_HANDLER = { 'class': 'logging.handlers.RotatingFileHandler', 'maxBytes': 1024 * 1024 * 50, # 50MB 'backupCount': 10, } LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'filters': { 'require_debug_false': { '()': 'django.utils.log.RequireDebugFalse',
""" from .base import * # noqa import logging import os import raven SITE_ID = 2 ROOT_URLCONF = 'config.urls_comingsoon' print('Loading comingsoon_production') RAVEN_CONFIG = { 'dsn': env('DJANGO_SENTRY_DSN'), # If you are using git, you can also automatically configure the # release based on the git info. 'release': raven.fetch_git_sha(str(ROOT_DIR - 1)), } # DEBUG # ------------------------------------------------------------------------------ DEBUG = env.bool('DJANGO_DEBUG') # See: https://docs.djangoproject.com/en/dev/ref/settings/#template-debug TEMPLATES[0]['OPTIONS']['debug'] = DEBUG # SECRET CONFIGURATION # ------------------------------------------------------------------------------ # See: https://docs.djangoproject.com/en/dev/ref/settings/#secret-key # Raises ImproperlyConfigured exception if DJANGO_SECRET_KEY not in os.environ SECRET_KEY = env('DJANGO_SECRET_KEY') # DATABASE CONFIGURATION
MEDIA_URL = '/media/' MEDIA_ROOT = os.path.join(BASE_DIR, 'media') INTERNAL_IPS = ['127.0.0.1'] # Chapter 25 from django.contrib.messages import constants MESSAGE_LEVEL = constants.DEBUG # 장고 기본설정으로 debug 메세지는 무시. 위와같이 설정해야 debug레벨의 메시지를 남길 수 있음 # 그러나 debug 거의 잘 안쓰니까 안 하는 것도 좋은 방법 MESSAGE_TAGS = {constants.ERROR: 'danger'} # ERROR level은 유지하나, 이에 대한 tag는 danger로 출력되도록 설정 NAVER_CLIENT_ID = 'fPxIUCZvzoI_d0aHAVAY' import raven GIT_ROOT = os.path.join(BASE_DIR, '..') # .git 파일을 담고있는 디렉토리가 GIT_ROOT가 되도록 설정 if os.path.exists(os.path.join(GIT_ROOT, '.git')): release = raven.fetch_git_sha(GIT_ROOT) # 현재 최근 커밋해시 획득 else: release = 'dev' RAVEN_CONFIG = { 'dsn': 'https://*****:*****@sentry.io/264500', # If you are using git, you can also automatically configure the # release based on the git info. 'release': release, }
'easy_thumbnails.processors.autocrop', 'filer.thumbnail_processors.scale_and_crop_with_subject_location', 'easy_thumbnails.processors.filters' ) SITE_ID = 1 # Sentry.io # https://docs.sentry.io/clients/python/integrations/django/ RAVEN_CONFIG = { 'dsn': os.getenv('SENTRY_DSN', ''), # If you are using git, you can also automatically configure the # release based on the git info. 'release': raven.fetch_git_sha(BASE_DIR), } LOGGING = { 'version': 1, 'disable_existing_loggers': True, 'root': { 'level': 'WARNING', 'handlers': ['sentry'], }, 'formatters': { 'verbose': { 'format': '%(levelname)s %(asctime)s %(module)s ' '%(process)d %(thread)d %(message)s' }, },
import os from raven import fetch_git_sha # Flask config DEBUG = True ROOT_DIR = os.path.dirname(__file__) HOST_NAME = 'localhost' APP_NAME = 'conditional' IP = '0.0.0.0' PORT = 6969 # LDAP config LDAP_RO = True LDAP_BIND_DN = 'cn=conditional,ou=Apps,dc=csh,dc=rit,dc=edu' LDAP_BIND_PW = '' # Sentry config # Do not set the DSN for local development SENTRY_CONFIG = { 'dsn': '', 'release': fetch_git_sha(ROOT_DIR), } # Database config SQLALCHEMY_DATABASE_URI = 'sqlite:///{}'.format( os.path.join(os.getcwd(), "data.db")) ZOO_DATABASE_URI = 'mysql+pymysql://user:pass@host/database' # General config DUES_PER_SEMESTER = 80
MAIN_APP_NAME + '.apps.network', MAIN_APP_NAME + '.apps.orientation', MAIN_APP_NAME + '.apps.printers', MAIN_APP_NAME + '.apps.residents', MAIN_APP_NAME + '.apps.rosters', MAIN_APP_NAME + '.apps.technicians', MAIN_APP_NAME + '.apps.uploaders', ) # ================================================================================================ # # Logging Configuration # # ================================================================================================ # RAVEN_CONFIG = { 'dsn': get_env_variable('RESNET_INTERNAL_SENTRY_DSN'), 'release': raven.fetch_git_sha(str(PROJECT_DIR.resolve())), } LOGGING = { 'version': 1, 'disable_existing_loggers': True, 'root': { 'level': 'WARNING', 'handlers': ['sentry'], }, 'formatters': { 'verbose': { 'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s' }, },
'handlers': ['console'], 'level': LOGLEVEL }, 'schedule': { 'handlers': ['console'], 'level': LOGLEVEL }, 'scheduler': { 'handlers': ['console'], 'level': LOGLEVEL }, 'sensor': { 'handlers': ['console'], 'level': LOGLEVEL }, 'status': { 'handlers': ['console'], 'level': LOGLEVEL } } } SENTRY_DSN = environ.get('SENTRY_DSN') if SENTRY_DSN: import raven RAVEN_CONFIG = { 'dsn': SENTRY_DSN, 'release': raven.fetch_git_sha(REPO_ROOT), }
import sys import raven from raven import Client, os SENTRY_DSN = os.getenv("SENTRY_DSN", "https://*****:*****@app.getsentry.com/10000") GIT_SHA = raven.fetch_git_sha(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))) client = Client(dsn=SENTRY_DSN, release=GIT_SHA) def write_stdout(s): # only eventlistener protocol messages may be sent to stdout sys.stdout.write(s) sys.stdout.flush() def write_stderr(s): sys.stderr.write(s) sys.stderr.flush() def main(): while 1: # transition from ACKNOWLEDGED to READY write_stdout("READY\n") # read header line and print it to stderr line = sys.stdin.readline() write_stderr(line) # read event payload and print it to stderr
'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ] ########## # Sentry # ########## try: git_sha = fetch_git_sha(BASE_DIR) except InvalidGitRepository: git_sha = None RAVEN_CONFIG = { 'dsn': env.str('SENTRY_DSN', default=None), 'release': git_sha, } ############################ # Languages & Localization # ############################ LANGUAGE_CODE = 'en' TIME_ZONE = 'UTC' ADMIN_TIME_ZONE = 'Europe/Helsinki' USE_I18N = True USE_L10N = True
class FragDenStaat(FragDenStaatBase): DEBUG = False TEMPLATE_DEBUG = False CELERY_TASK_ALWAYS_EAGER = False CELERY_TASK_EAGER_PROPAGATES = False CELERY_SEND_TASK_ERROR_EMAILS = True ADMINS = (('FragDenStaat.de', '*****@*****.**'), ) MANAGERS = (('FragDenStaat.de', '*****@*****.**'), ) SECURE_FRAME_DENY = True SECURE_CONTENT_TYPE_NOSNIFF = True SECURE_BROWSER_XSS_FILTER = True CSRF_COOKIE_SECURE = True SESSION_COOKIE_SECURE = True DATA_UPLOAD_MAX_MEMORY_SIZE = 15728640 STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.ManifestStaticFilesStorage' STATIC_URL = 'https://static.frag-den-staat.de/static/' SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTOCOL', 'https') USE_X_ACCEL_REDIRECT = True X_ACCEL_REDIRECT_PREFIX = '/protected' ALLOWED_HOSTS = ('fragdenstaat.de', 'media.frag-den-staat.de', 'testserver') ALLOWED_REDIRECT_HOSTS = ( 'fragdenstaat.de', 'sanktionsfrei.de', ) CACHES = {'default': django_cache_url.config()} DATABASES = { 'default': { 'ENGINE': 'django.contrib.gis.db.backends.postgis', 'NAME': env('DATABASE_NAME'), 'OPTIONS': {}, 'HOST': env('DATABASE_HOST'), 'USER': env('DATABASE_USER'), 'PASSWORD': env('DATABASE_PASSWORD'), 'PORT': '' } } @property def TEMPLATES(self): TEMP = super(FragDenStaat, self).TEMPLATES TEMP[0]['OPTIONS']['debug'] = False loaders = TEMP[0]['OPTIONS']['loaders'] TEMP[0]['OPTIONS']['loaders'] = [ ('django.template.loaders.cached.Loader', loaders) ] return TEMP CELERY_BROKER_URL = env('DJANGO_CELERY_BROKER_URL') CUSTOM_AUTH_USER_MODEL_DB = 'auth_user' DEFAULT_FROM_EMAIL = 'FragDenStaat.de <*****@*****.**>' EMAIL_BACKEND = 'djcelery_email.backends.CeleryEmailBackend' CELERY_EMAIL_BACKEND = 'froide.foirequest.smtp.EmailBackend' # EMAIL_HOST # EMAIL_HOST_PASSWORD # EMAIL_HOST_USER EMAIL_SUBJECT_PREFIX = '[AdminFragDenStaat] ' EMAIL_USE_TLS = True EMAIL_PORT = 25 # FOI_EMAIL_ACCOUNT_NAME # FOI_EMAIL_ACCOUNT_PASSWORD FOI_EMAIL_DOMAIN = ['fragdenstaat.de', 'echtemail.de'] FOI_EMAIL_FIXED_FROM_ADDRESS = False FOI_EMAIL_FUNC = None # Values from env # FOI_EMAIL_HOST # FOI_EMAIL_HOST_FROM # FOI_EMAIL_HOST_IMAP # FOI_EMAIL_HOST_PASSWORD # FOI_EMAIL_HOST_USER FOI_EMAIL_PORT = 25 FOI_EMAIL_PORT_IMAP = 143 FOI_EMAIL_USE_SSL = False FOI_EMAIL_USE_TLS = True FOI_MEDIA_PATH = 'foi' BOUNCE_EMAIL_PORT_IMAP = 143 GEOIP_PATH = env('DJANGO_GEOIP_PATH') ELASTICSEARCH_INDEX_PREFIX = 'fragdenstaat_de' ELASTICSEARCH_DSL = { 'default': { 'hosts': 'localhost:9200' }, } ELASTICSEARCH_DSL_SIGNAL_PROCESSOR = 'froide.helper.search.CelerySignalProcessor' LOGGING = { 'loggers': { 'froide': { 'level': 'INFO', 'propagate': True, 'handlers': ['normal'] }, 'sentry.errors': { 'handlers': ['normal'], 'propagate': False, 'level': 'DEBUG' }, 'django.request': { 'level': 'ERROR', 'propagate': True, 'handlers': ['normal'] }, 'raven': { 'handlers': ['normal'], 'propagate': False, 'level': 'DEBUG' } }, 'disable_existing_loggers': False, 'handlers': { 'normal': { 'filename': os.path.join(env('DJANGO_LOG_DIR'), 'froide.log'), 'class': 'logging.FileHandler', 'level': 'INFO' } }, 'formatters': { 'verbose': { 'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s' } }, 'version': 1, 'filters': { 'require_debug_false': { '()': 'django.utils.log.RequireDebugFalse' } }, 'root': { 'handlers': ['normal'], 'level': 'WARNING' } } MANAGERS = (('FragDenStaat.de', '*****@*****.**'), ) MEDIA_ROOT = env('DJANGO_MEDIA_ROOT') MEDIA_URL = 'https://media.frag-den-staat.de/files/' FOI_MEDIA_TOKENS = True FOI_MEDIA_DOMAIN = 'https://media.frag-den-staat.de' FILE_UPLOAD_DIRECTORY_PERMISSIONS = 0o2750 FILE_UPLOAD_PERMISSIONS = 0o640 SECRET_KEY = env('DJANGO_SECRET_KEY') SECRET_URLS = {'admin': env('DJANGO_SECRET_URL_ADMIN')} _base_dir = os.path.abspath( os.path.join(os.path.dirname(__file__), '..', '..')) RAVEN_CONFIG = {'release': raven.fetch_git_sha(_base_dir)} if env('DJANGO_SENTRY_DSN') is not None: RAVEN_CONFIG['dsn'] = env('DJANGO_SENTRY_DSN') SERVER_EMAIL = '*****@*****.**' SITE_EMAIL = '*****@*****.**' SITE_ID = 1 SITE_NAME = 'FragDenStaat' SITE_URL = 'https://fragdenstaat.de' META_SITE_PROTOCOL = 'https' TASTYPIE_DEFAULT_FORMATS = ['json'] @property def OAUTH2_PROVIDER(self): P = super(FragDenStaat, self).OAUTH2_PROVIDER P['ALLOWED_REDIRECT_URI_SCHEMES'] = ['https', 'fragdenstaat'] return P
def create_app(test_config=None): app = Flask(__name__) # override _get_file_stream() so we avoid spooling to disk app.request_class = RAMOnlyRequest try: GIT_RELEASE = raven.fetch_git_sha('.') except Exception as e: print("WARNING: couldn't set sentry git release automatically: " + str(e), file=sys.stderr) GIT_RELEASE = None app.config.from_mapping( SECRET_KEY='dev', GIT_REV = GIT_RELEASE, VERSION = __version__, SENTRY_CONFIG = { 'enable-threads': True, # for uWSGI 'release': GIT_RELEASE, }, ) # Grabs sentry config from SENTRY_DSN environment variable sentry = Sentry(app) @app.route('/', methods = ['GET']) def toplevel(): return "okay!" @app.route('/api/list', methods = ['GET']) def list_api(): """ Show the REST api. """ # build HTML of the method list apilist = [] rules = sorted(app.url_map.iter_rules(), key=lambda x: str(x)) for rule in rules: f = app.view_functions[rule.endpoint] docs = f.__doc__ or '' # remove noisy OPTIONS methods = sorted([x for x in rule.methods if x != "OPTIONS"]) url = html.escape(str(rule)) apilist.append("<div><a href='{}'><b>{}</b></a> {}<br/>{}</div>".format( url, url, methods, docs)) header = """<body> <style> body { width: 80%; margin: 20px auto; font-family: Courier; } section { background: #eee; padding: 40px 20px; border: 1px dashed #aaa; } </style> <section> <h2>REST API (_COUNT_ end-points)</h2> """.replace('_COUNT_', str(len(apilist))) footer = "</section></body>" return header + "<br/>".join(apilist) + footer from pdf_trio import api_routes app.register_blueprint(api_routes.bp) return app
def init_web_settings(app_name, debug, sentry_dsn, early_middleware=(), late_middleware=()): """ Appends extra Django settings useful specifically for web apps, such as static files handling, etc. :param sentry_dsn: a string containing the DSN to configure the raven client. Projects defining this parameter MUST add `raven` to their pip requirements. settings: dict return: dict """ # Load settings dict into local scope for concision and coherence settings = init_settings(app_name, debug) staticfiles_dirs = (os.path.join(settings["APP_ROOT_DIR"], "static"),) # Needs its own line to avoid pragma no cover bleeding into other statements staticfiles_storage = ( "whitenoise.storage.CompressedManifestStaticFilesStorage" if not settings["TESTING"] else "django.contrib.staticfiles.storage.StaticFilesStorage" ) # pragma: no cover template_context_processors = settings.get("TEMPLATE_CONTEXT_PROCESSORS", ()) + ( ("django.core.context_processors.debug",) if debug else () ) # pragma: no cover settings.update( { # Installed apps "INSTALLED_APPS": ("whitenoise.runserver_nostatic", "django.contrib.staticfiles") + settings["INSTALLED_APPS"], # Routing "ROOT_URLCONF": app_name + ".urls", # Static files, templates "STATIC_ROOT": "staticfiles", "STATIC_URL": "/static/", "STATICFILES_DIRS": staticfiles_dirs, # Don't use Whitenoise's static files storage in testing as it requires running collectstatic "STATICFILES_STORAGE": staticfiles_storage, "WHITENOISE_ROOT": staticfiles_dirs[0] + "/files", "WHITENOISE_ALLOW_ALL_ORIGINS": False, "TEMPLATE_CONTEXT_PROCESSORS": template_context_processors, } ) ########## # SENTRY # ########## if sentry_dsn: # pragma: no cover settings["INSTALLED_APPS"] = ("raven.contrib.django.raven_compat",) + settings["INSTALLED_APPS"] settings["LOGGING"]["handlers"]["sentry"] = { "level": "ERROR", "class": "raven.contrib.django.raven_compat.handlers.SentryHandler", } settings["LOGGING"]["root"]["handlers"].append("sentry") # import-error disabled: Raven shall only be a dependency of projects that define sentry_dsn import raven # pylint: disable=wrong-import-position, wrong-import-order, import-error settings["RAVEN_CONFIG"] = {"dsn": sentry_dsn} try: settings["RAVEN_CONFIG"]["release"] = raven.fetch_git_sha(settings["PROJECT_ROOT_DIR"]) except raven.exceptions.InvalidGitRepository: # Probably not a git repo (on heroku?) pass settings["MIDDLEWARE_CLASSES"] = _compute_middleware_settings( early_middleware, late_middleware, use_sentry=bool(sentry_dsn) ) return settings
'backupCount': 5 } LOGGING['loggers']['wagtail']['handlers'].append('wagtail_file') # Error log LOGGING['handlers']['errors_file'] = { 'level': 'ERROR', 'class': 'cloghandler.ConcurrentRotatingFileHandler', 'filename': os.path.join(env['LOG_DIR'], 'error.log'), 'maxBytes': 5242880, # 5MB 'backupCount': 5 } LOGGING['loggers']['django.request']['handlers'].append('errors_file') LOGGING['loggers']['django.security']['handlers'].append('errors_file') try: from .local import * # noqa except ImportError: pass # Raven (sentry error logging) # This must be after the .local import as RAVEN_DSN is set in local.py if 'RAVEN_DSN' in os.environ: RAVEN_CONFIG = { 'dsn': os.environ['RAVEN_DSN'], 'release': raven.fetch_git_sha(os.path.dirname(os.path.abspath(PROJECT_ROOT))), }
TIME_ZONE = 'UTC' USE_I18N = True USE_L10N = True USE_TZ = True STATICFILES_FINDERS = ( 'django.contrib.staticfiles.finders.FileSystemFinder', 'django.contrib.staticfiles.finders.AppDirectoriesFinder', ) STATICFILES_DIRS = [ os.path.join(BASE_DIR, "dist") ] STATICFILES_STORAGE = "django.contrib.staticfiles.storage.CachedStaticFilesStorage" # Static files (CSS, JavaScript, Images) # https://docs.djangoproject.com/en/1.9/howto/static-files/ STATIC_URL = '/static/' MEDIA_URL = '/media/' import raven if "RAVEN_DNS_WHATIS" in os.environ and not DEBUG: RAVEN_CONFIG = { 'dsn': os.environ['RAVEN_DNS_WHATIS'], 'release': raven.fetch_git_sha(os.path.join(os.path.dirname(__file__), "../")), }
PASSWORD_RESET_TIMEOUT_DAYS = 2 ACCOUNT_ACTIVATION_DAYS = 2 REGISTRATION_OPEN = True # set to false to temporarily disable registrations MESSAGE_STORAGE = "django.contrib.messages.storage.session.SessionStorage" MESSAGE_TAGS = {messages.ERROR: "danger"} SENTRY_BACKEND_DSN = os.environ.get("SENTRY_BACKEND_DSN", "") SENTRY_FRONTEND_DSN = os.environ.get("SENTRY_FRONTEND_DSN", "") RAVEN_CONFIG = { "dsn": SENTRY_BACKEND_DSN, "environment": CONCORDIA_ENVIRONMENT, "release": raven.fetch_git_sha(SITE_ROOT_DIR), } # When the MAINTENANCE_MODE setting is true, this template will be used to # generate a 503 response: MAINTENANCE_MODE_TEMPLATE = "maintenance-mode.html" # Names of special django.auth Groups COMMUNITY_MANAGER_GROUP_NAME = "Community Managers" NEWSLETTER_GROUP_NAME = "Newsletter" # Django sites framework setting SITE_ID = 1 ROBOTS_USE_SITEMAP = False ROBOTS_USE_HOST = False
# The mailbox is called 'de rest'. EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend' EMAIL_HOST = 'mailtrap.io' EMAIL_HOST_USER = '******' EMAIL_HOST_PASSWORD = '******' EMAIL_PORT = 25 # Make sure to add the correct DSN in production.py # This project is called 'De rest' RAVEN_CONFIG = { 'dsn': 'https://*****:*****@sentry.io/111454', } try: import raven import os RAVEN_CONFIG['release'] = raven.fetch_git_sha(os.path.dirname(os.pardir)) except ImportError: pass # Application definition INSTALLED_APPS = [ '{{ cookiecutter.repo_name }}.home', '{{ cookiecutter.repo_name }}.search', 'overextends', 'wagtail.contrib.wagtailsearchpromotions', 'wagtail.wagtailforms', 'wagtail.wagtailredirects',
def create_app(_read_config=True, **config): app = Flask( __name__, static_folder=os.path.join(ROOT, "static"), template_folder=os.path.join(ROOT, "templates"), ) # support for kubernetes # https://kubernetes.io/docs/concepts/services-networking/service/ if os.environ.get("GET_HOSTS_FROM") == "env": REDIS_URL = "redis://{}:{}/0".format( os.environ["REDIS_MASTER_SERVICE_HOST"], os.environ["REDIS_MASTER_SERVICE_PORT"], ) # Cloud SQL # https://cloud.google.com/sql/docs/postgres/connect-container-engine SQLALCHEMY_URI = "postgresql+psycopg2://{}:{}@127.0.0.1:5432/zeus".format( os.environ["DB_USER"], os.environ["DB_PASSWORD"]) if "CELERY_BROKER_URL" in os.environ: app.config["CELERY_BROKER_URL"] = os.environ["CELERY_BROKER_URL"] if "GCS_BUCKET" in os.environ: app.config["FILE_STORAGE"] = { "backend": "zeus.storage.gcs.GoogleCloudStorage", "options": { "bucket": os.environ["GCS_BUCKET"], "project": os.environ.get("GC_PROJECT"), }, } app.config.setdefault("MAIL_SERVER", os.environ.get("MAIL_SERVER")) app.config.setdefault("MAIL_PORT", os.environ.get("MAIL_PORT")) app.config.setdefault("MAIL_USE_TLS", bool(int(os.environ.get("MAIL_USE_TLS", "1")))) app.config.setdefault("MAIL_USE_SSL", bool(int(os.environ.get("MAIL_USE_SSL", "0")))) app.config.setdefault("MAIL_USERNAME", os.environ.get("MAIL_USERNAME")) app.config.setdefault("MAIL_PASSWORD", os.environ.get("MAIL_PASSWORD")) app.config.setdefault("MAIL_DEFAULT_SENDER", os.environ.get("MAIL_DEFAULT_SENDER")) app.config.setdefault( "ALLOWED_ORIGINS", [ x.strip() for x in os.environ.get("ALLOWED_ORIGINS", "").split(",") if x.strip() ], ) else: REDIS_URL = os.environ.get("REDIS_URL", "redis://localhost/0") SQLALCHEMY_URI = os.environ.get("SQLALCHEMY_DATABASE_URI", "postgresql+psycopg2:///zeus") app.config["FILE_STORAGE"] = { "backend": "zeus.storage.base.FileStorage", "options": {} } app.config["CELERY_BROKER_URL"] = REDIS_URL app.config.setdefault( "MAIL_DEFAULT_SENDER", "{}@localhost".format(os.environ.get("USERNAME", "root"))) if os.environ.get("SERVER_NAME"): app.config["SERVER_NAME"] = os.environ["SERVER_NAME"] app.config.setdefault( "DOMAIN", app.config.get("SERVER_NAME") or os.environ.get("DOMAIN") or "localhost", ) app.config["PUBSUB_ENDPOINT"] = os.environ.get("PUBSUB_ENDPOINT", "http://localhost:8090") app.config["SECRET_KEY"] = os.environ.get("SECRET_KEY") app.config["LOG_LEVEL"] = os.environ.get("LOG_LEVEL") or "INFO" app.config["SSL"] = os.environ.get("SSL") in ("1", "true", "on") # limit sessions to one day so permissions are revalidated automatically app.config["PERMANENT_SESSION_LIFETIME"] = timedelta(days=1) app.config["SQLALCHEMY_DATABASE_URI"] = SQLALCHEMY_URI app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False app.config["REDIS_URL"] = REDIS_URL app.config["STREAM_URL"] = "http://localhost:8090/stream" app.config["SENTRY_DSN"] = os.environ.get("SENTRY_DSN") or None app.config["SENTRY_DSN_FRONTEND"] = os.environ.get( "SENTRY_DSN_FRONTEND") or None app.config["SENTRY_INCLUDE_PATHS"] = ["zeus"] try: app.config["SENTRY_RELEASE"] = raven.fetch_git_sha(ROOT) except Exception: app.logger.warn("unable to bind sentry.release context", exc_info=True) app.config["SENTRY_ENVIRONMENT"] = os.environ.get("NODE_ENV", "development") app.config["GITHUB_CLIENT_ID"] = os.environ.get("GITHUB_CLIENT_ID") or None app.config["GITHUB_CLIENT_SECRET"] = os.environ.get( "GITHUB_CLIENT_SECRET") or None app.config["WEBPACK_MANIFEST_PATH"] = os.path.join(ROOT, "static", "asset-manifest.json") app.config["CELERY_ACCEPT_CONTENT"] = ["zeus_json", "json"] app.config["CELERY_ACKS_LATE"] = True app.config.setdefault("CELERY_BROKER_URL", app.config["REDIS_URL"]) app.config["CELERY_DEFAULT_QUEUE"] = "default" app.config["CELERY_DEFAULT_EXCHANGE"] = "default" app.config["CELERY_DEFAULT_EXCHANGE_TYPE"] = "direct" app.config["CELERY_DEFAULT_ROUTING_KEY"] = "default" app.config["CELERY_DISABLE_RATE_LIMITS"] = True app.config["CELERY_EVENT_SERIALIZER"] = "zeus_json" app.config["CELERY_IGNORE_RESULT"] = True app.config["CELERY_IMPORTS"] = ("zeus.tasks", ) app.config["CELERY_RESULT_BACKEND"] = None app.config["CELERY_RESULT_SERIALIZER"] = "zeus_json" # app.config['CELERY_SEND_EVENTS'] = False app.config["CELERY_TASK_RESULT_EXPIRES"] = 1 app.config["CELERY_TASK_SERIALIZER"] = "zeus_json" # dont let any task run longer than 5 minutes app.config["CELERY_TASK_SOFT_TIME_LIMIT"] = 300 # hard kill tasks after 6 minutes app.config["CELERY_TASK_TIME_LIMIT"] = 360 # app.config['CELERYD_PREFETCH_MULTIPLIER'] = 1 # app.config['CELERYD_MAX_TASKS_PER_CHILD'] = 10000 app.config["CELERYBEAT_SCHEDULE_FILE"] = os.path.join( tempfile.gettempdir(), "zeus-celerybeat") app.config["CELERYBEAT_SCHEDULE"] = { "sync-all-repos": { "task": "zeus.sync_all_repos", "schedule": timedelta(minutes=5) }, "cleanup-builds": { "task": "zeus.cleanup_builds", "schedule": timedelta(minutes=5) }, "cleanup-artifacts": { "task": "zeus.cleanup_artifacts", "schedule": timedelta(minutes=60) }, } app.config["REDBEAT_REDIS_URL"] = app.config["REDIS_URL"] app.config["WORKSPACE_ROOT"] = WORKSPACE_ROOT app.config["REPO_ROOT"] = os.environ.get( "REPO_ROOT", os.path.join(WORKSPACE_ROOT, "zeus-repos")) app.config["ARTIFACT_RETENTION"] = timedelta(days=30) if _read_config: if os.environ.get("ZEUS_CONF"): # ZEUS_CONF=/etc/zeus.conf.py app.config.from_envvar("ZEUS_CONF") else: # Look for $WORKSPACE_ROOT/zeus.conf.py app.config.from_pyfile(os.path.join(WORKSPACE_ROOT, "zeus.config.py"), silent=True) app.wsgi_app = with_health_check(app.wsgi_app) app.config.update(config) app.config.setdefault("MAIL_SUPPRESS_SEND", app.debug or app.testing) # HACK(dcramer): the CLI causes validation to happen on init, which it shouldn't if "init" not in sys.argv: req_vars = ( "GITHUB_CLIENT_ID", "GITHUB_CLIENT_SECRET", "REDIS_URL", "SECRET_KEY", "SQLALCHEMY_DATABASE_URI", ) for varname in req_vars: if not app.config.get(varname): raise SystemExit( "Required configuration not present for {}".format( varname)) from zeus.testutils.client import ZeusTestClient app.test_client_class = ZeusTestClient if app.config.get("LOG_LEVEL"): app.logger.setLevel(getattr(logging, app.config["LOG_LEVEL"].upper())) # oauthlib compat app.config["GITHUB_CONSUMER_KEY"] = app.config["GITHUB_CLIENT_ID"] app.config["GITHUB_CONSUMER_SECRET"] = app.config["GITHUB_CLIENT_SECRET"] # init sentry first sentry.init_app(app) # XXX(dcramer): Sentry + Flask + Logging integration is broken # https://github.com/getsentry/raven-python/issues/1030 from raven.handlers.logging import SentryHandler app.logger.addHandler( SentryHandler(client=sentry.client, level=logging.WARN)) if app.config["SSL"]: ssl.init_app(app) configure_db(app) # needs to happen after db configure_scout(app) redis.init_app(app) mail.init_app(app) celery.init_app(app, sentry) configure_webpack(app) configure_api(app) configure_web(app) from . import models # NOQA return app
from .base import * import raven import environ # env settings in env variable or env file env = environ.Env(DEBUG=(bool, False), ) # set default values and casting environ.Env.read_env(os.path.join(BASE_DIR, ".env")) # reading .env file SECRET_KEY = env("SECRET_KEY") ALLOWED_HOSTS = env("ALLOWED_HOSTS").split(",") print("Allowed hosts:%s" % ALLOWED_HOSTS) # get the current git release version RELEASE = raven.fetch_git_sha(BASE_DIR)[:8] print ("Aha!book release: %s" % RELEASE) ########## DEBUG DEBUG = True print("Debug mode:%s" % DEBUG) # depreceated - https://docs.djangoproject.com/en/1.8/ref/settings/#template-debug # set by DEBUG - https://docs.djangoproject.com/en/1.8/topics/templates/#django.template.backends.django.DjangoTemplates # TEMPLATE_DEBUG = DEBUG # SERVE_MEDIA = DEBUG INSTALLED_APPS += [ 'debug_toolbar', ]
default='https://www.googleapis.com/oauth2/v1/certs'), 'client_x509_cert_url': env('GA_CLIENT_X509_CERT_URL', default='') } HOTJAR_CONFIG = { 'hjid': env.int('HOTJAR_ID', default=0), 'hjsv': env.int('HOTJAR_SV', default=0), } # Sentry SENTRY_USER = env('SENTRY_USER', default='') SENTRY_PASSWORD = env('SENTRY_PASSWORD', default='') SENTRY_ADDRESS = env('SENTRY_ADDRESS', default='') SENTRY_JS_DSN = env.str('SENTRY_JS_DSN', default='') SENTRY_PROJECT = env('SENTRY_PROJECT', default='') RELEASE = raven.fetch_git_sha(os.path.abspath( os.pardir)) if SENTRY_USER else '' RAVEN_JS_VERSION = env.str('RAVEN_JS_VERSION', default='3.26.4') if SENTRY_ADDRESS and SENTRY_PROJECT: RAVEN_CONFIG = { 'dsn': f'https://{SENTRY_USER}:{SENTRY_PASSWORD}@{SENTRY_ADDRESS}/{SENTRY_PROJECT}', 'release': RELEASE, } # List of github usernames to not count as comments on an issue IGNORE_COMMENTS_FROM = [ 'gitcoinbot', ] # optional: only needed if you run the activity-report management command AWS_STORAGE_BUCKET_NAME = env('AWS_STORAGE_BUCKET_NAME', default='')
'USER': '', 'PASSWORD': '', 'HOST': '', 'PORT': '', # not needed anymore due to migration to postgres # 'OPTIONS': { # 'init_command': "SET sql_mode='STRICT_TRANS_TABLES'", # } } } RAVEN_CONFIG = { 'dsn': '', # If you are using git, you can also automatically configure the # release based on the git info. 'release': raven.fetch_git_sha(os.path.dirname(__file__)), } # Email setting EMAIL_USE_TLS = True EMAIL_HOST = 'smtp.' EMAIL_HOST_USER = '******' EMAIL_HOST_PASSWORD = '' EMAIL_PORT = 587 DEFAULT_FROM_EMAIL = '@avaika.me' SERVER_EMAIL = '@avaika.me' # Social auth SOCIAL_AUTH_TWITTER_KEY = '' SOCIAL_AUTH_TWITTER_SECRET = ''
import raven INSTALLED_APPS = INSTALLED_APPS + ('raven.contrib.django.raven_compat', ) RAVEN_CONFIG = { 'dsn': os.environ['RAVEN_DSN'], } # Set the `server_name` attribute. See https://docs.sentry.io/hosted/clients/python/advanced/ server_name = os.environ.get('RAVEN_SERVER_NAME') server_name = server_name or '.'.join( filter(None, (os.environ.get('KOBOFORM_PUBLIC_SUBDOMAIN', None), os.environ.get('PUBLIC_DOMAIN_NAME', None)))) if server_name: RAVEN_CONFIG.update({'name': server_name}) try: RAVEN_CONFIG['release'] = raven.fetch_git_sha(BASE_DIR) except raven.exceptions.InvalidGitRepository: pass # The below is NOT required for Sentry to log unhandled exceptions, but it # is necessary for capturing messages sent via the `logging` module. # https://docs.getsentry.com/hosted/clients/python/integrations/django/#integration-with-logging LOGGING = { 'version': 1, 'disable_existing_loggers': False, # Was `True` in Sentry documentation 'root': { 'level': 'WARNING', 'handlers': ['sentry'], }, 'formatters': { 'verbose': {
'django': { 'handlers': [ {%- if cookiecutter.use_sentry == 'y' %} 'sentry', {%- endif %} 'console', ], 'level': 'ERROR', 'propagate': True, }, }, } {%- if cookiecutter.use_sentry == 'y' %} try: release = raven.fetch_git_sha(root()) except raven.exceptions.InvalidGitRepository: release = 'unknown' RAVEN_CONFIG = { 'dsn': env('SENTRY_DSN'), 'release': release, } {%- endif %} # if 'test' in sys.argv: # DATABASES['default'] = {'ENGINE': 'django.db.backends.sqlite3'} if DEBUG: import socket
"user-agent", "accept-encoding", "accept-crs", "content-crs", ) # Raven SENTRY_DSN = os.getenv("SENTRY_DSN") if SENTRY_DSN: INSTALLED_APPS = INSTALLED_APPS + ["raven.contrib.django.raven_compat"] if "GIT_SHA" in os.environ: GIT_SHA = os.getenv("GIT_SHA") else: GIT_SHA = raven.fetch_git_sha(BASE_DIR) RAVEN_CONFIG = {"dsn": SENTRY_DSN, "release": GIT_SHA} LOGGING["handlers"].update( { "sentry": { "level": "WARNING", "class": "raven.handlers.logging.SentryHandler", "dsn": RAVEN_CONFIG["dsn"], } } ) # # SSL or not? #
if APM_SECRET_TOKEN: ELASTIC_APM['SECRET_TOKEN'] = APM_SECRET_TOKEN if DEBUG and ENV == 'stage': ELASTIC_APM['DEBUG'] = True AWS_ACCESS_KEY_ID = env('AWS_ACCESS_KEY_ID', default='') AWS_SECRET_ACCESS_KEY = env('AWS_SECRET_ACCESS_KEY', default='') AWS_DEFAULT_REGION = env('AWS_DEFAULT_REGION', default='us-west-2') AWS_LOG_GROUP = env('AWS_LOG_GROUP', default='Gitcoin') AWS_LOG_LEVEL = env('AWS_LOG_LEVEL', default='INFO') AWS_LOG_STREAM = env('AWS_LOG_STREAM', default=f'{ENV}-web') # Sentry SENTRY_DSN = env.str('SENTRY_DSN', default='') SENTRY_JS_DSN = env.str('SENTRY_JS_DSN', default=SENTRY_DSN) RELEASE = raven.fetch_git_sha(os.path.abspath( os.pardir)) if ENV == 'prod' else '' RAVEN_JS_VERSION = env.str('RAVEN_JS_VERSION', default='3.26.4') if SENTRY_DSN: sentry_sdk.init(SENTRY_DSN, integrations=[DjangoIntegration(), CeleryIntegration()], traces_sample_rate=0.35) RAVEN_CONFIG = { 'dsn': SENTRY_DSN, } if RELEASE: RAVEN_CONFIG['release'] = RELEASE LOGGING = { 'version': 1, 'disable_existing_loggers': False,
DEFAULT_FROM_EMAIL = '*****@*****.**' EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend' # As required by debug_toolbar INTERNAL_IPS = ( '10.0.2.2', # external '127.0.0.1' # localhost ) INSTALLED_APPS += ( #'debug_toolbar', # 'debug_panel', ) MIDDLEWARE_CLASSES = ( #'debug_toolbar.middleware.DebugToolbarMiddleware', # 'debug_panel.middleware.DebugPanelMiddleware', ) + MIDDLEWARE_CLASSES RAVEN_CONFIG.update({ 'release': raven.fetch_git_sha(DJANGO_ROOT) }) try: from .local import * except ImportError: pass
# # Show active environment in admin. ENVIRONMENT = "production" SHOW_ALERT = False # We will assume we're running under https SESSION_COOKIE_SECURE = True SESSION_COOKIE_HTTPONLY = True CSRF_COOKIE_SECURE = True X_FRAME_OPTIONS = "DENY" # Only set this when we're behind Nginx as configured in our example-deployment SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https") SECURE_CONTENT_TYPE_NOSNIFF = True # Sets X-Content-Type-Options: nosniff SECURE_BROWSER_XSS_FILTER = True # Sets X-XSS-Protection: 1; mode=block # # Library settings # # Raven INSTALLED_APPS = INSTALLED_APPS + ["raven.contrib.django.raven_compat"] RAVEN_CONFIG = {"dsn": "https://", "release": raven.fetch_git_sha(BASE_DIR)} LOGGING["handlers"].update({ "sentry": { "level": "WARNING", "class": "raven.handlers.logging.SentryHandler", "dsn": RAVEN_CONFIG["dsn"], } })
# Not used with sqlite3. "USER": "******", # Not used with sqlite3. "PASSWORD": "******", # Set to empty string for localhost. Not used with sqlite3. "HOST": "127.0.0.1", # Set to empty string for default. Not used with sqlite3. "PORT": "", } } RAVEN_CONFIG = { 'dsn': "%(sentry_dsn)s", # If you are using git, you can also automatically configure the # release based on the git info. 'release': raven.fetch_git_sha(dirname(dirname(dirname(dirname(__file__))))), } EMAIL_HOST = "%(email_host)s" SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTOCOL", "https") CACHE_MIDDLEWARE_SECONDS = 60 TIMEOUT = 300 CACHES = { "default": { "BACKEND": "django.core.cache.backends.memcached.MemcachedCache", "LOCATION": "127.0.0.1:11211", "KEY_PREFIX": "%(proj_name)s",
}, }, 'loggers': { 'django': { 'handlers': ['console'], 'level': os.getenv('DJANGO_LOG_LEVEL', 'INFO'), }, 'importer': { 'handlers': ['console'], 'level': os.getenv('DJANGO_LOG_LEVEL', 'INFO'), } }, } try: GIT_VERSION = raven.fetch_git_sha( os.path.abspath(os.path.join(BASE_DIR, ".."))) except raven.exceptions.InvalidGitRepository: GIT_VERSION = "undef" pass RAVEN_CONFIG = { 'dsn': get_env_str('SENTRY_DSN', None), 'release': get_env_str('VERSION', GIT_VERSION), } MONGODB_HOST = get_env_str("MONGODB_HOST", "localhost") MONGODB_PORT = get_env_int("MONGODB_PORT", 27017) MONGODB_USERNAME = get_env_str("MONGODB_USERNAME", "") MONGODB_PASSWORD = get_env_str("MONGODB_PASSWORD", "") MONGODB_AUTH_DB = get_env_str("MONGODB_AUTH_DB", "admin") MONGODB_DB = get_env_str("MONGODB_DB", "ragoogle_spiders")
AWS_SES_REGION_NAME = os.environ.get('AWS_SES_REGION_NAME') AWS_SES_REGION_ENDPOINT = os.environ.get('AWS_SES_REGION_ENDPOINT') ''' Sentry configuration ''' # Optional Sentry configuration: if desired, be sure to install Raven and set # RAVEN_DSN in the environment if 'RAVEN_DSN' in os.environ: try: import raven except ImportError: print 'Please install Raven to enable Sentry logging.' else: INSTALLED_APPS = INSTALLED_APPS + ( 'raven.contrib.django.raven_compat', ) RAVEN_CONFIG = { 'dsn': os.environ['RAVEN_DSN'], } # Set the `server_name` attribute. See https://docs.sentry.io/hosted/clients/python/advanced/ server_name = os.environ.get('RAVEN_SERVER_NAME') server_name = server_name or os.environ.get('KOBOCAT_PUBLIC_SUBDOMAIN', '') + \ os.environ.get('PUBLIC_DOMAIN_NAME', '') if server_name: RAVEN_CONFIG.update({'name': server_name}) try: RAVEN_CONFIG['release'] = raven.fetch_git_sha(BASE_DIR) except raven.exceptions.InvalidGitRepository: pass
USE_I18N = True USE_L10N = True USE_TZ = False # Static files (CSS, JavaScript, Images) # https://docs.djangoproject.com/en/1.11/howto/static-files/ STATIC_URL = '/static/' LISTNER_URL = listner_url LISTNER_PORT = listner_port PRINTER_URL = printer_url LOGIN_REDIRECT_URL = '/queue/' STATIC_ROOT = '/home/admintrud/shawarma/shawarma_rep/static_content/static/' RAVEN_CONFIG = { 'dsn': raven_dsn, # If you are using git, you can also automatically configure the # release based on the git info. 'release': raven.fetch_git_sha(os.path.abspath(os.pardir)), }
# } DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': 'postgres', 'USER': '******', 'HOST': 'db', 'PORT': 5432, } } RAVEN_CONFIG = { 'dsn': 'http://*****:*****@sentry:9000/1', # If you are using git, you can also automatically configure the # release based on the git info. 'release': raven.fetch_git_sha(os.path.abspath(os.pardir)), } LOGGING = { 'version': 1, 'disable_existing_loggers': True, 'root': { 'level': 'WARNING', 'handlers': ['sentry'], }, 'formatters': { 'verbose': { 'format': '%(levelname)s %(asctime)s %(module)s ' '%(process)d %(thread)d %(message)s' }, },
STATIC_URL = '/static/' STATIC_ROOT = os.path.join(BASE_DIR, 'static/') REST_FRAMEWORK = { 'DEFAULT_PERMISSION_CLASSES': [ 'rest_framework.permissions.IsAdminUser', ], 'DEFAULT_RENDERER_CLASSES': ('rest_framework.renderers.JSONRenderer', ) } import raven RAVEN_CONFIG = { 'environment': 'production', 'dsn': os.getenv("SENTRY_DSN"), 'release': raven.fetch_git_sha(os.path.dirname(os.pardir)), } LOGGING = { 'version': 1, 'disable_existing_loggers': True, 'root': { 'level': 'INFO', 'handlers': ['sentry'], }, 'formatters': { 'simple': { 'format': '%(asctime)s SENDER_NAME PROGRAM_NAME: %(message)s', 'datefmt': '%Y-%m-%dT%H:%M:%S', }, 'verbose': {
# more details on how to customize your logging configuration. LOGGING = { "version": 1, "disable_existing_loggers": False, "filters": {"require_debug_false": {"()": "django.utils.log.RequireDebugFalse"}}, "handlers": { "mail_admins": { "level": "ERROR", "filters": ["require_debug_false"], "class": "django.utils.log.AdminEmailHandler", } }, "loggers": {"django.request": {"handlers": ["mail_admins"], "level": "ERROR", "propagate": True}}, } ADMINS = ( ("Ian Dees", "*****@*****.**"), ("Joe Germuska", "*****@*****.**"), ("Ryan Pitts", "*****@*****.**"), ) MANAGERS = ADMINS API_URL = "https://api.censusreporter.org" import raven RAVEN_CONFIG = { "dsn": os.environ.get("SENTRY_DSN"), "release": raven.fetch_git_sha(os.path.dirname(__file__) + "/../../.."), }
# Visually differentiate the environments from prod: # with a colored breadcrumb... CRUDLFAP_TEMPLATE_BACKEND['OPTIONS']['constants'].update( dict(BACKGROUND_COLOR=COLORS.get(INSTANCE.upper(), ''), )) # and the page's title. TITLE_SUFFIX = "" if INSTANCE.upper() != 'PRODUCTION': TITLE_SUFFIX = " ({})".format(INSTANCE.upper()) RELEASE = os.getenv('GIT_COMMIT', '') if not RELEASE: repo = os.path.join(os.path.dirname(__file__), '..', '..') if os.path.exists(os.path.join(repo, '.git')): RELEASE = raven.fetch_git_sha(repo) RAVEN_CONFIG = dict( dsn=os.getenv('SENTRY_DSN', ''), transport=RequestsHTTPTransport, ) RAVEN_PUBLIC_CONFIG = dict( environment=INSTANCE, release=RELEASE, ) RAVEN_CONFIG.update(RAVEN_PUBLIC_CONFIG) SENTRY_PUBLIC_DSN = strip_password(RAVEN_CONFIG['dsn']) CRUDLFAP_TEMPLATE_BACKEND['OPTIONS']['constants'].update( dict( SENTRY_DSN=SENTRY_PUBLIC_DSN,