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 = [

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

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

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

                ('levelno', models.IntegerField(verbose_name=b'log level')),

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

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

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

            ],

            options={

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

            },

        ),

    ]

import jsonfield

        self.logger = ProxyLogger(self.log_level, self.get_connector_slug(), self.slug)

class ResourceLog(models.Model):

    timestamp = models.DateTimeField(auto_now_add=True)

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

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

    levelno = models.IntegerField(verbose_name='log level')

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

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

        )

    def __unicode__(self):

        return '%s %s %s %s' % (self.timestamp, self.levelno, self.appname, self.slug)

    @property

    def message(self):

        return base64.b64decode(self._message)

    @message.setter

    def message(self, value):

        self._message = base64.b64encode(value)

    def save(self, *args, **kwargs):

        try:

            base64.b64decode(self._message)

        except (TypeError,):

            self._message = base64.encode(self._message)

        return super(ResourceLog, self).save(*args, **kwargs)

class ProxyLogger(object):

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

        self.appname = appname

        self.slug = slug

        if appname:

            logger_name = 'passerelle.resource.%s.%s' % (self.appname, self.slug)

        else:

            logger_name = 'passerelle.resource'

        self._logger = logging.getLogger(logger_name)

        self._logger.setLevel(level)

    def _log(self, levelname, message, *args, **kwargs):

        levelno = getattr(logging, levelname)

        attr = {}

        attr['levelno'] = levelno

        attr['message'] = message

        attr['appname'] = self.appname

        attr['slug'] = self.slug

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

        request = kwargs.pop('request', None)

        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

        attr['ipsource'] = ipsource

        if self._logger.level <= levelno:

            ResourceLog.objects.create(**attr)

        getattr(self._logger, levelname.lower())(message, *args, **kwargs)

    def debug(self, message, *args, **kwargs):

        self._log('DEBUG', message, *args, **kwargs)

    def info(self, message, *args, **kwargs):

        self._log('INFO', message, *args, **kwargs)

    def warning(self, message, *args, **kwargs):

        self._log('WARNING', message, *args, **kwargs)

    def critical(self, message, *args, **kwargs):

        self._log('CRITICAL', message, *args, **kwargs)

    def error(self, message, *args, **kwargs):

        self._log('ERROR', message, *args, **kwargs)

    def fatal(self, message, *args, **kwargs):

        self._log('FATAL', message, *args, **kwargs)

from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

from ..models import AccessRight, ResourceLog

@register.inclusion_tag('passerelle/includes/resource-logs-table.html', takes_context=True)

def resource_logs_table(context, resource):

    request = context.get('request')

    page = request.GET.get('page', 1)

    connector = resource.get_connector_slug()

    context['connector'] = connector

    context['slug'] = resource.slug

    qs = ResourceLog.objects.filter(appname=connector, slug=resource.slug).order_by('-timestamp')

    paginator = Paginator(qs, 10)

    try:

        logrecords = paginator.page(page)

    except PageNotAnInteger:

        logrecords = paginator.page(1)

    except (EmptyPage,):

        logrecords = paginator.page(paginator.num_pages)

    context['logrecords'] = logrecords

    return context

{% load i18n passerelle %}

{% load tz %}

{% block content %}

{% if logrecords %}

<table class="main">

    <thead>

        <th>{% trans 'Id' %}</th>

        <th>{% trans 'Timestamp' %}</th>

        <th>{% trans 'Level' %}</th>

        <th>{% trans 'Ip Source' %}</th>

        <th>{% trans 'Message' %}</th>

    </thead>

    <tbody>

    {% for record in logrecords %}

    <tr>

        <td>{{ record.id }}</td>

        <td>{{ record.timestamp|localtime }}</td>

        <td>{{ record.loglevel }}</td>

        <td>{{ record.ipsource }}</td>

        <td>{{ record.message}}</td>

    </tr>

    {% endfor %}

    </tbody>

</table>

{% if logrecords.has_other_pages %}

<p class="paginator">

  {% if logrecords.has_previous %}

      <a href="?page={{ logrecords.previous_page_number }}#logs">&lt;&lt;</a>

  {% else %}

  <span>&lt;&lt;</span>

  {% endif %}

     

    <span class="current">

        {{ logrecords.number }} / {{ logrecords.paginator.num_pages }}

    </span>

      

    {% if logrecords.has_next %}

        <a href="?page={{ logrecords.next_page_number }}#logs">&gt;&gt;</a>

    {% else %}

        <span>&gt;&gt;</span>

    {% endif %}

        </div>

    {% endif %}

{% else %}

<p>{% trans 'No records found' %}</p>

{% endif %}

{% endblock %}

{% if perms.base.view_resourcelog %}

<div id="logs">

    <h3>{% trans "Logs" %}</h3>

    {% block logs %}

        {% resource_logs_table resource=object %}

    {% endblock %}

</div>

{% endif %}

                               request=request,

import base64

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

@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.levelno == 10:

            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)

    logger.debug('new token: %s (timeout %ss)', 'hfgjsfg=', 45)

    # Resource Custom DB Logger

    log = ResourceLog.objects.filter(appname='arcgis', slug='test').first()

    assert log.appname == 'arcgis'

    assert log.slug == 'test'

    assert log.levelno == 10

    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.levelno == 20

    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().levelno == 30

    # when logging a file

    ResourceLog.objects.all().delete()

    filename = os.path.join(os.path.dirname(__file__), 'data', 'iparapheur_test.pdf')

    message = '<file_content>(%r)</file_content>' % file(filename).read()

    logger.debug(message)

    assert ResourceLog.objects.count() == 1

    assert ResourceLog.objects.first().levelno == 10

    assert ResourceLog.objects.first()._message == base64.b64encode(message)