Python raven.fetch_git_sha函数代码示例

    def setup(cls):
        super(Base, cls).setup()

        cls.RAVEN_CONFIG = {
            'dsn': cls.SENTRY_DSN,
            'release': raven.fetch_git_sha(cls.PROJECT_PATH),
        }

    def RAVEN_CONFIG(self):
        import raven

        return {
            'dsn': str(super().SENTRY_DSN),
            'release': raven.fetch_git_sha(super().BASE_DIR),
        }

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 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)

        '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))),
    }

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']

        '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

}

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, '..')),
    }

    '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'
        },
    },

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