Produits Entr'ouvert » Passerelle

# -*- coding: utf-8 -*-

from __future__ import unicode_literals

from django.db import migrations, models

import jsonfield.fields

class Migration(migrations.Migration):

    dependencies = [

        ('contenttypes', '0002_remove_content_type_name'),

        ('base', '0002_auto_20151009_0326'),

    ]

    operations = [

        migrations.CreateModel(

            name='ResourceLog',

            fields=[

                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),

                ('timestamp', models.DateTimeField(auto_now_add=True)),

                ('resource_pk', models.PositiveIntegerField(null=True, blank=True)),

                ('connector', models.CharField(max_length=128, null=True, verbose_name=b'connector')),

                ('appname', models.CharField(max_length=128, null=True, verbose_name=b'appname')),

                ('slug', models.CharField(max_length=128, null=True, verbose_name=b'slug')),

                ('loglevel', models.CharField(max_length=16, verbose_name=b'log level')),

                ('ipsource', models.GenericIPAddressField(null=True, verbose_name='IP Address', blank=True)),

                ('message', models.TextField(max_length=2048, verbose_name=b'message')),

                ('extra', jsonfield.fields.JSONField(default={}, verbose_name=b'extras')),

                ('resource_type', models.ForeignKey(blank=True, to='contenttypes.ContentType', null=True)),

            ],

            options={

                'permissions': (('view_resourcelog', 'Can view resource logs'),),

            },

        ),

    ]

import jsonfield

        self.logger = ProxyLogger(self.log_level, self.__class__.__name__,

                                  self.get_connector_slug(), self.slug)

class ResourceLog(models.Model):

    timestamp = models.DateTimeField(auto_now_add=True)

    resource_type = models.ForeignKey(ContentType, blank=True, null=True)

    resource_pk = models.PositiveIntegerField(blank=True, null=True)

    resource = fields.GenericForeignKey('resource_type', 'resource_pk')

    connector = models.CharField(max_length=128, verbose_name='connector', null=True)

    appname = models.CharField(max_length=128, verbose_name='appname', null=True)

    slug = models.CharField(max_length=128, verbose_name='slug', null=True)

    loglevel = models.CharField(max_length=16, verbose_name='log level')

    ipsource = models.GenericIPAddressField(blank=True, null=True, verbose_name=_('IP Address'))

    message = models.TextField(max_length=2048, verbose_name='message')

    extra = jsonfield.JSONField(verbose_name='extras', default={})

    class Meta:

        permissions = (

            ('view_resourcelog', 'Can view resource logs'),

        )

class ProxyLogger(object):

    def __init__(self, level, classname=None, appname=None, slug=None):

        self.classname = classname

        self.appname = appname

        self.slug = slug

        if classname:

            logger_name = 'passerelle.resource.%s.%s' % (

                slugify(unicode(self.classname.lower())), self.slug)

        else:

            logger_name = 'passerelle.resource'

        self._logger = logging.getLogger(logger_name)

        self._logger.setLevel(level)

    def _log(self, levelname, message, request=None, **extra):

        attr = {}

        attr['loglevel'] = levelname

        attr['message'] = message

        attr['extra'] = extra.get('extra', {})

        if getattr(request, 'META', None):

            if 'HTTP_X_FORWARDED_FOR' in request.META:

                ipsource = request.META.get('HTTP_X_FORWARDED_FOR', '').split(",")[0].strip()

            else:

                ipsource = request.META.get('REMOTE_ADDR')

        else:

            ipsource = None

        if self.classname and self.slug:

            connector = '%s-%s' % (self.classname.lower(), self.slug)

            klass = ContentType.objects.get(model=self.classname.lower())

            klass_pk = klass.pk

            # instance = ContentType.get_object_for_this_type(klass, slug=self.slug)

        else:

            connector = None

            klass = None

            klass_pk = None

        attr['ipsource'] = ipsource

        attr['connector'] = connector

        attr['resource_type'] = klass

        attr['resource_pk'] = klass_pk

        # Resource Custom DB Loggger

        if self._logger.level <= getattr(logging, levelname.upper()):

            ResourceLog.objects.create(**attr)

        # Default Resource Logger

        getattr(self._logger, levelname)(message, extra=extra.get('extra', {}))

    def debug(self, message, request=None, **extra):

        self._log('debug', message, request, **extra)

    def info(self, message, request=None, **extra):

        self._log('info', message, request, **extra)

    def warning(self, message, request=None, **extra):

        self._log('warning', message, request, **extra)

    def error(self, message, request=None, **extra):

        self._log('error', message, request, **extra)

    def critical(self, message, request=None, **extra):

        self._log('critical', message, request, **extra)

    def fatal(self, message, request=None, **extra):

        self._log('fatal', message, request, **extra)

            'class': 'logging.StreamHandler'

        },

                               request=request,

from passerelle.base.models import ResourceLog, ProxyLogger

from passerelle.contrib.arcgis.models import Arcgis

@pytest.fixture

def arcgis(db):

    return utils.setup_access_rights(Arcgis.objects.create(slug='test', log_level='DEBUG'))

        # assert record.module == 'views'

@mock.patch('passerelle.utils.LoggedRequest.get')

def test_proxy_logger(mocked_get, caplog, app, arcgis):

    payload = file(os.path.join(os.path.dirname(__file__), 'data', 'nancy_arcgis', 'sigresponse.json')).read()

    mocked_get.return_value = utils.FakedResponse(content=payload, status_code=200)

    # simple logger

    logger = ProxyLogger('DEBUG')

    logger.debug('this is a debug test')

    logger.info('this is an info test')

    assert ResourceLog.objects.count() == 2

    for log in ResourceLog.objects.all():

        if log.loglevel == 'debug':

            assert log.message == 'this is a debug test'

        else:

            assert log.message == 'this is an info test'

    resp = app.get('/arcgis/test/district', {'lon': 6.172122, 'lat': 48.673836}, status=200)

    # Resource Custom DB Logger

    log = ResourceLog.objects.filter(connector='arcgis-test')[0]

    assert log.connector == 'arcgis-test'

    assert log.loglevel == 'debug'

    assert log.ipsource == '127.0.0.1'

    assert log.extra['connector'] == 'arcgis'

    assert log.extra['connector_endpoint'] == 'district'

    assert log.extra['connector_endpoint_method'] == 'GET'

    assert log.extra['connector_endpoint_url'] == '/arcgis/test/district?lat=48.673836&lon=6.172122'

    # Resource Generic Logger

    for record in caplog.records():

        if record.name != 'passerelle.resource.arcgis.test':

            continue

        assert record.levelno == 10

        assert record.levelname == 'DEBUG'

        assert record.name == 'passerelle.resource.arcgis.test'

        assert record.message == u"endpoint GET /arcgis/test/district?lat=48.673836&lon=6.172122 ('') "

    data = resp.json['data']

    assert data['id'] == 4

    assert data['text'] == 'HAUSSONVILLE / BLANDAN / MON DESERT / SAURUPT'

    # when changing log level

    ResourceLog.objects.all().delete()

    arcgis.log_level = 'INFO'

    arcgis.save()

    app.get('/arcgis/test/district', {'lon': 6.172122, 'lat': 48.673836}, status=200)

    assert ResourceLog.objects.count() == 0

    arcgis.logger.info('testing info log message')

    assert ResourceLog.objects.count() == 1

    log = ResourceLog.objects.first()

    assert log.connector == 'arcgis-test'

    assert log.loglevel == 'info'

    assert log.message == 'testing info log message'

    arcgis.logger.warning('first warning')

    assert ResourceLog.objects.count() == 2

    assert ResourceLog.objects.last().message == 'first warning'

    assert ResourceLog.objects.last().loglevel == 'warning'