"""

Stackify Python API

"""

__version__ = '0.0.1'

API_URL = 'https://api.stackify.com'

READ_TIMEOUT = 5000

MAX_BATCH = 100

QUEUE_SIZE = 1000

import logging

import inspect

import atexit

DEFAULT_LEVEL = logging.ERROR

LOGGING_LEVELS = {

logging.CRITICAL: 'CRITICAL',

logging.ERROR: 'ERROR',

logging.WARNING: 'WARNING',

logging.INFO: 'INFO',

logging.DEBUG: 'DEBUG',

logging.NOTSET: 'NOTSET'

}

class NullHandler(logging.Handler):

def emit(self, record):

pass

logging.getLogger(__name__).addHandler(NullHandler())

from stackify.application import ApiConfiguration

from stackify.http import HTTPClient

from stackify.handler import StackifyHandler

def getLogger(name=None, auto_shutdown=True, basic_config=True, **kwargs):

'''Get a logger and attach a StackifyHandler if needed.

You can pass this function keyword arguments for Stackify configuration.

If they are omitted you can specify them through environment variables:

* STACKIFY_API_KEY

* STACKIFY_APPLICATION

* STACKIFY_ENVIRONMENT

* STACKIFY_API_URL

Args:

name: The name of the logger (or None to automatically make one)

auto_shutdown: Register an atexit hook to shut down logging

basic_config: Set up with logging.basicConfig() for regular logging

Optional Args:

api_key: Your Stackify API key

application: The name of your Stackify application

environment: The Stackfiy environment to log to

api_url: An optional API url if required

Returns:

A logger instance with Stackify handler and listener attached.

'''

if basic_config:

logging.basicConfig()

if not name:

name = getCallerName(2)

logger = logging.getLogger(name)

if not [isinstance(x, StackifyHandler) for x in logger.handlers]:

internal_logger = logging.getLogger(__name__)

internal_logger.debug('Creating handler for logger %s', name)

handler = StackifyHandler(**kwargs)

logger.addHandler(handler)

if auto_shutdown:

internal_logger.debug('Registering atexit callback')

atexit.register(stopLogging, logger)

if logger.getEffectiveLevel() == logging.NOTSET:

logger.setLevel(DEFAULT_LEVEL)

handler.listener.start()

return logger

def stopLogging(logger):

'''Stop logging on the Stackify handler.

Shut down the StackifyHandler on a given logger. This will block

and wait for the queue to finish uploading.

'''

internal_logger = logging.getLogger(__name__)

internal_logger.debug('Shutting down all handlers')

for handler in getHandlers(logger):

handler.listener.stop()

def getCallerName(levels=1):

'''Gets the name of the module calling this function'''

try:

frame = inspect.stack()[levels]

module = inspect.getmodule(frame[0])

name = module.__name__

except IndexError:

name = 'stackify-python-unknown'

return name

def getHandlers(logger):

'''Return the StackifyHandlers on a given logger'''

return [x for x in logger.handlers if isinstance(x, StackifyHandler)]