def run_test():
"""Run."""
logger = airbrake.getLogger(environment='airbrake-python-test')
abhandler = find_ab_handler(logger)
# abhandler.airbrake.deploy()
try:
1 / 0
except ZeroDivisionError:
logger.exception("Bad math.")
try:
undefined # noqa
except Exception:
logger.exception("Undefined things!",
extra={
'additional': 'context',
'key1': 'val1'
})
logger.error("No exception, but something to be concerned about.")
abhandler = find_ab_handler(logger)
response = abhandler.airbrake.log(message='Finishing real test.')
response.raise_for_status()
def get_logger(ENV, BASE_DIR):
# temporary
is_email_script = pathlib.Path(sys.argv[0]).name == "email_db_report.py"
# use Airbrake in production
if(ENV=="production" and not is_email_script):
log = airbrake.getLogger()
log.setLevel(logging.INFO)
else:
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
# print all debug and higher to STDOUT
# if the environment is development
if(ENV=="development"):
stdoutHandler = logging.StreamHandler(sys.stdout)
stdoutHandler.setLevel(logging.DEBUG)
log.addHandler(stdoutHandler)
logfile = os.path.abspath(BASE_DIR + "/logs/CivilServant_" + ENV + ".log")
print("Logging to " + BASE_DIR + "/logs/CivilServant_" + ENV + ".log")
formatter = logging.Formatter('%(asctime)s - %(name)s({env}) - %(levelname)s - %(message)s'.format(env=ENV))
rotateHandler = ConcurrentRotatingFileHandler(logfile, "a", 32 * 1000 * 1024, 5)
rotateHandler.setLevel(logging.DEBUG)
rotateHandler.setFormatter(formatter)
log.addHandler(rotateHandler)
return log
def get_logger(ENV, BASE_DIR):
# use Airbrake in production
is_email_script = pathlib.Path(sys.argv[0]).name == "email_db_report.py"
if ENV == "production" and not is_email_script:
log = airbrake.getLogger()
log.setLevel(logging.INFO)
else:
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
# Return the logger as-is if it has already been initialized
handlers = [h for h in log.handlers if type(h) != airbrake.AirbrakeHandler]
if len(handlers) > 0:
return log
# print all debug and higher to STDOUT
# if the environment is development
if (ENV == "development"):
stdoutHandler = logging.StreamHandler(sys.stdout)
stdoutHandler.setLevel(logging.DEBUG)
log.addHandler(stdoutHandler)
logfile = os.path.abspath(BASE_DIR + "/logs/CivilServant_" + ENV + ".log")
print("Logging to " + BASE_DIR + "/logs/CivilServant_" + ENV + ".log")
formatter = logging.Formatter(
'%(asctime)s - %(name)s({env}) - %(levelname)s - %(message)s'.format(
env=ENV))
rotateHandler = ConcurrentRotatingFileHandler(logfile, "a",
32 * 1000 * 1024, 5)
rotateHandler.setLevel(logging.DEBUG)
rotateHandler.setFormatter(formatter)
log.addHandler(rotateHandler)
return log
def get_logger(ENV, BASE_DIR):
# use Airbrake in production
if (ENV == "production"):
log = airbrake.getLogger()
log.setLevel(logging.INFO)
else:
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
# print all debug and higher to STDOUT
# if the environment is development
if (ENV == "development"):
stdoutHandler = logging.StreamHandler(sys.stdout)
stdoutHandler.setLevel(logging.DEBUG)
log.addHandler(stdoutHandler)
logfile = os.path.abspath(BASE_DIR + "/logs/CivilServant_" + ENV + ".log")
print("Logging to " + BASE_DIR + "/logs/CivilServant_" + ENV + ".log")
formatter = logging.Formatter(
'%(asctime)s - %(name)s({env}) - %(levelname)s - %(message)s'.format(
env=ENV))
rotateHandler = ConcurrentRotatingFileHandler(logfile, "a",
32 * 1000 * 1024, 5)
rotateHandler.setLevel(logging.DEBUG)
rotateHandler.setFormatter(formatter)
log.addHandler(rotateHandler)
return log
def setUp(self):
super(TestAirbrakeNotifier, self).setUp()
self.logger = airbrake.getLogger(
'custom-loglevel',
api_key='fakekey', project_id='fakeprojectid')
self.session = {'user_id': 100}
self.environment = {'PATH': '/usr/bin/'}
def get_logger():
# use Airbrake in production
airbrake_config = load_airbrake_config()
if airbrake_config:
log = airbrake.getLogger(**airbrake_config)
log.setLevel(logging.INFO)
else:
log = logging.getLogger(__name__)
log.setLevel(logging.INFO)
# print all debug and higher to STDOUT
# if the environment is development
# stdoutHandler = logging.StreamHandler(sys.stdout)
# stdoutHandler.setLevel(logging.ERROR)
# log.addHandler(stdoutHandler)
BASE_DIR = os.path.join(os.path.dirname(hostbotai.__file__), '..')
logfile = os.path.abspath(BASE_DIR + "/logs/hb.log")
# print("Logging to " + BASE_DIR + "/logs/hb.log")
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
rotateHandler = RotatingFileHandler(logfile, mode='a', maxBytes=1024*(10**3), backupCount=5, encoding='utf-8', delay=0)
# rotateHandler = ConcurrentRotatingFileHandler(logfile, "a", 32 * 1000 * 1024, backupCount=1000)
rotateHandler.setLevel(logging.INFO)
rotateHandler.setFormatter(formatter)
log.addHandler(rotateHandler)
return log
def setUp(self):
super(TestAirbrakeNotifier, self).setUp()
self.logger = airbrake.getLogger('test-notifier',
api_key='fakekey',
project_id='fakeprojectid')
self.session = {'user_id': 100}
self.environment = {'PATH': '/usr/bin/'}
self.context = {
'hostname': socket.gethostname(),
'os': platform.platform(),
'language': 'Python/%s' % platform.python_version(),
'notifier': __notifier__,
'rootDirectory': os.getcwd()
}
def get_logger(ENV=None, BASE_DIR=None):
if ENV is None:
ENV = os.getenv('HUMANIKI_ENV', 'development')
search_from = BASE_DIR if BASE_DIR else __file__
BASE_DIR = get_ancestor_directory_that_has_xdir_as_child(
xdir='logs', caller__file__=search_from)
# use Airbrake in production
if ENV == "production":
log = airbrake.getLogger()
log.setLevel(logging.INFO)
else:
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
# Return the logger as-is if it has already been initialized
handlers = [h for h in log.handlers if type(h) != airbrake.AirbrakeHandler]
if len(handlers) > 0:
return log
# print all debug and higher to STDOUT
# if the environment is development
if (ENV == "development"):
stdoutHandler = logging.StreamHandler(sys.stdout)
stdoutHandler.setLevel(logging.DEBUG)
log.addHandler(stdoutHandler)
logfile = os.path.abspath(
os.path.join(BASE_DIR, "logs", f"humaniki_{ENV}.log"))
print(f"Logging to {logfile}")
formatter = logging.Formatter(
'%(asctime)s - %(name)s({env}) - %(levelname)s - %(message)s'.format(
env=ENV))
rotateHandler = ConcurrentRotatingFileHandler(logfile, "a",
32 * 1000 * 1024, 5)
rotateHandler.setLevel(logging.DEBUG)
rotateHandler.setFormatter(formatter)
log.addHandler(rotateHandler)
return log
def run_test():
"""Run."""
logger = airbrake.getLogger(environment="airbrake-python-test")
abhandler = find_ab_handler(logger)
# abhandler.airbrake.deploy()
try:
1 / 0
except ZeroDivisionError:
logger.exception("Bad math.")
try:
undefined # noqa
except Exception:
logger.exception("Undefined things!", extra={"additional": "context", "key1": "val1"})
logger.error("No exception, but something to be concerned about.")
abhandler = find_ab_handler(logger)
response = abhandler.airbrake.log(message="Finishing real test.")
response.raise_for_status()
def run_test():
logger = airbrake.getLogger(environment='airbrake-python-test')
abhandler = find_ab_handler(logger)
# abhandler.airbrake.deploy()
try:
1/0
except ZeroDivisionError:
logger.exception("Bad math.")
try:
undefined
except Exception as err:
logger.exception("Undefined things!",
extra={'additional': 'context', 'key1': 'val1'})
logger.error("No exception, but something to be concerned about.")
abhandler = find_ab_handler(logger)
response = abhandler.airbrake.log(message='Finishing real test.')
response.raise_for_status()
def test_auto_logger_given_name(self):
logger = airbrake.getLogger("my_module", api_key="fakekey", project_id="fakeprojectid")
self.assertTrue(logger.isEnabledFor(logging.ERROR))
def test_auto_logger_given_name(self):
logger = airbrake.getLogger('my_module',
api_key='fakekey',
project_id='fakeprojectid')
self.assertTrue(logger.isEnabledFor(logging.ERROR))
def setUp(self):
super(TestCustomLogLevel, self).setUp()
self.logger = airbrake.getLogger('custom-loglevel',
api_key='fakekey',
project_id='fakeprojectid',
level=BRAKE_LEVEL)
def setUp(self):
super(TestAirbrakeHandlerBasic, self).setUp()
self.logger = airbrake.getLogger(api_key='fakekey',
project_id='fakeprojectid')
self.logmsg = "There's your problem, right there."
import boto3
import botocore
import copy
import logging
import threading
from collections import deque
from r4.client import AbstractFileManager, AbstractProvider
from r4.client.s3 import S3
from r4.client.r4 import R4, FileSystem
import airbrake
error_logger = airbrake.getLogger(api_key="1001b69b71a13ef204b4a8ac1e38d9ad",
project_id=157356)
# try:
# 1/0
# except Exception:
# logger.exception("Bad math.")
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
print = logger.info
class UploadManagerFactory(object):
'''
Create a class to manage upload performance
'''
def __init__(self, data=None, fractional_upload=1):
if not isinstance(data, bytes):
self.data = ''.encode('utf-8')
def test_one_logger(self):
logger = airbrake.getLogger(api_key="fakekey", project_id="fakeprojectid")
self.assertEqual(1, len(logger.handlers))
import airbrake
import optimus as op
from pyspark.sql.types import StringType, IntegerType, StructType, StructField
from pyspark.sql.functions import col
import pyspark
import sys
logger = airbrake.getLogger()
def assert_spark_df(df):
assert (isinstance(df, pyspark.sql.dataframe.DataFrame))
def create_df(spark_session):
try:
# Building a simple dataframe:
schema = StructType([
StructField("city", StringType(), True),
StructField("country", StringType(), True),
StructField("population", IntegerType(), True)
])
countries = ['Colombia ', 'US@A', 'Brazil', 'Spain']
cities = ['Bogotá', 'New York', ' São Paulo ', '~Madrid']
population = [37800000, 19795791, 12341418, 6489162]
# Dataframe:
df = spark_session.createDataFrame(list(
zip(cities, countries, population)),
schema=schema)
app.jinja_env.filters["escapejs"] = lambda val: json.dumps(val)
app.jinja_env.add_extension("jinja2.ext.do")
app.register_blueprint(api)
app.register_blueprint(anonymous_blueprint)
app.register_blueprint(authenticated_blueprint)
handle_errors(app)
if env.airbrake:
with open("../.git/refs/heads/master", "r") as f:
head = f.read()
logger.info("Initializing Airbrake")
import airbrake
airbrake_logger = airbrake.getLogger(api_key=env.airbrake_key,
project_id=env.airbrake_id)
def log_exception(sender, exception, **extra):
extra["commit"] = head
airbrake_logger.exception(exception, extra=extra)
got_request_exception.connect(log_exception, app)
# Client-IPs von NGINX übernehmen
app.wsgi_app = ProxyFix(app.wsgi_app)
def address_string(self):
if not hasattr(self, "headers"):
return self.client_address[0]
forwarded_for = self.headers.get('X-Forwarded-For', '').split(',')
def setUp(self):
super(TestCustomLogLevel, self).setUp()
self.logger = airbrake.getLogger(
'custom-loglevel',
api_key='fakekey', project_id='fakeprojectid',
level=BRAKE_LEVEL)
def setUp(self):
super(TestAirbrakeHandlerBasic, self).setUp()
self.logger = airbrake.getLogger(
api_key='fakekey', project_id='fakeprojectid')
self.logmsg = "There's your problem, right there."
def test_two_logger(self):
airbrake.getLogger(
api_key='fakekey', project_id='fakeprojectid')
logger = airbrake.getLogger(
api_key='fakekey', project_id='fakeprojectid')
self.assertEqual(1, len(logger.handlers))
def test_auto_logger_given_name(self):
logger = airbrake.getLogger(
'my_module', api_key='fakekey', project_id='fakeprojectid')
self.assertTrue(
logger.isEnabledFor(logging.ERROR))
def setUp(self):
super(TestCustomLogLevel, self).setUp()
self.logger = airbrake.getLogger(
"custom-loglevel", api_key="fakekey", project_id="fakeprojectid", level=BRAKE_LEVEL
)
logger.info("Initializing Sentry")
class MySentry(Sentry):
def before_request(self, *args, **kwargs):
Sentry.before_request(self, *args, **kwargs)
self.client.extra_context({
"commit": head,
"dirty": dirty,
})
self.client.tags_context({"isDirty": len(dirty) > 0})
sentry = MySentry(app, logging=True, level=logging.ERROR)
if env.airbrake:
with open("../.git/refs/heads/master", "r") as f: head = f.read()
logger.info("Initializing Airbrake")
import airbrake
airbrake_logger = airbrake.getLogger(api_key=env.airbrake_key, project_id=env.airbrake_id)
def log_exception(sender, exception, **extra):
extra["commit"] = head
airbrake_logger.exception(exception, extra=extra)
got_request_exception.connect(log_exception, app)
# Client-IPs von NGINX übernehmen
app.wsgi_app = ProxyFix(app.wsgi_app)
def address_string(self):
if not hasattr(self, "headers"):
return self.client_address[0]
forwarded_for = self.headers.get('X-Forwarded-For', '').split(',')
if forwarded_for and forwarded_for[0]:
return forwarded_for[0]
else:
import airbrake
import ckan.model as model
import ckan.plugins as plugins
import ckan.plugins.toolkit as toolkit
import os
# Setup error logger
if os.getenv('AIRBRAKE_API_KEY'):
logger = airbrake.getLogger(api_key=os.getenv('AIRBRAKE_API_KEY'),
project_id=os.getenv('AIRBRAKE_PROJECT_ID'))
def get_number_of_files():
return model.Session.execute("select count(*) from resource where state = 'active'").first()[0]
def get_number_of_external_links():
return model.Session.execute("select count(*) from resource where state = 'active' and url not LIKE '%data.gov.ro%'").first()[0]
class Romania_ThemePlugin(plugins.SingletonPlugin):
plugins.implements(plugins.IConfigurer)
plugins.implements(plugins.ITemplateHelpers)
def update_config(self, config):
toolkit.add_template_directory(config, 'templates')
toolkit.add_public_directory(config, 'public')
toolkit.add_resource('fanstatic', 'romania_theme')
def get_helpers(self):
return {'get_number_of_files': get_number_of_files,
'get_number_of_external_links': get_number_of_external_links}
'level': 'DEBUG',
'handlers': ['console', 'logstash'],
},
'django.request': {
'handlers': ['logstash'],
'level': 'DEBUG',
'propagate': True,
},
}
}
LOGGING = {}
try:
AIRBRAKE_API_KEY = os.environ.get('AIRBRAKE_API_KEY')
logger = airbrake.getLogger(api_key=AIRBRAKE_API_KEY, project_id=205620)
except:
pass
CACHES = {
'default': {
'BACKEND': 'speedinfo.backends.proxy_cache',
'CACHE_BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
'LOCATION': '/tmp/django_cache',
}
}
print('dev')
import decimal
# from speedinfo.settings import ReportColumnFormat, DEFAULTS
def setUp(self):
self.request = HttpRequest()
self.response = HttpResponse()
self.logger = airbrake.getLogger(
api_key='fakekey', project_id='fakeprojectid')
import airbrake
logger = airbrake.getLogger(api_key="cb2a3a75073aac41efac1818747f2ac5",
project_id=171162)
try:
1 / 0
except Exception:
logger.exception("Bad math.")
print(logger)
def test_two_logger(self):
airbrake.getLogger(api_key='fakekey', project_id='fakeprojectid')
logger = airbrake.getLogger(api_key='fakekey',
project_id='fakeprojectid')
self.assertEqual(1, len(logger.handlers))
