1

"""

     2

    Format LogLines into some other representation

     3

"""

     4

     5

import re, xml.sax.saxutils

     6

     7

from log_line import LogTypes

     8

     9

class LogFormatter (object) :

    10

    """

    11

        Provides a method to format series of LogLines into various output formats, with varying themes.

    12

    """

    13

    14

    # machine-readable name

    15

    name = None

    16

    17

    # human-readable name

    18

    title = None

    19

    20

    ## parameters

    21

    # use a fixed-width font for HTML output

    22

    html_fixedwidth = True

    23

    24

    def __init__ (self, tz, timestamp_fmt="%H:%M:%S") :

    25

        """

    26

            Initialize to format timestamps with the given timezone and timestamp

    27

        """

    28

    29

        self.tz = tz

    30

        self.timestamp_fmt = timestamp_fmt

    31

    32

    def _format_line_text (self, line, template_dict, full_timestamp=False) :

    33

        """

    34

            Format the given line as text, using the given { type: string template } dict

    35

        """

    36

    37

        # look up the template

    38

        template = template_dict[line.type]

    39

    40

        # convert timestamp into display timezone

    41

        dtz = line.timestamp.astimezone(self.tz)

    42

    43

        # full timestamps?

    44

        if full_timestamp :

    46

            timestamp_fmt = '%Y-%m-%d ' + self.timestamp_fmt

    47

    48

        else :

    49

            timestamp_fmt = self.timestamp_fmt

    50

    51

        # build timestamp

    52

        timestamp = dtz.strftime(timestamp_fmt)

    53

    54

        # format with dict

    55

        return template % dict(

    56

            timestamp       = timestamp,

    57

            source          = line.source,

    58

            data            = line.data,

    59

        )

    60

    61

    def format_txt (self, lines, full_timestamps=False) :

    62

        """

    63

            Format given lines as plaintext.

    64

    65

            If full_timestamps is given, the output will contain full timestamps with both date and time.

    66

    67

            No trailing newlines.

    68

        """

    69

    70

        abstract

    71

    72

    def format_html (self, lines, full_timestamps=False) :

    73

        """

    74

            Format as HTML.

    75

    76

            See format_txt for information about arguments

    77

        """

    78

    79

        abstract

    80

    81

class BaseHTMLFormatter (object) :

    82

    """

    83

        Implements some HTML-formatting utils

    84

    """

    85

    86

    URL_REGEXP = re.compile(r"http://\S+")

    87

    88

    def _process_links (self, line) :

    89

        """

    90

            Processed the rendered line, adding in <a href>'s for things that look like URLs, returning the new line.

    91

    92

            The line should already be escaped

    93

        """

    94

    95

        def _encode_url (match) :

    96

            # encode URL

    97

            url_html = match.group(0)

    98

            url_link = xml.sax.saxutils.unescape(url_html)

    99

   100

            return '<a href="%(url_link)s">%(url_html)s</a>' % dict(url_link=url_link, url_html=url_html)

   101

   102

        return self.URL_REGEXP.sub(_encode_url, line)

   103

   104

class IrssiTextFormatter (LogFormatter) :

   105

    """

   106

        Implements format_txt for irssi-style output

   107

    """

   108

   109

    # format definitions by type

   110

    __FMT = {

   111

        LogTypes.RAW        : "%(timestamp)s %(data)s",

   112

    }

   113

   114

    def format_txt (self, lines, full_timestamps=False) :

   115

        # ...handle each line

   116

        for line in lines :

   117

            # using __TYPES

   118

            yield line, self._format_line_text(line, self.__FMT, full_timestamps)

   119

   120

class IrssiFormatter (IrssiTextFormatter, BaseHTMLFormatter) :

   121

    """

   122

        Implements plain black-and-white irssi-style formatting

   123

    """

   124

   125

    # name

   126

    name = 'irssi'

   127

    title = "Irssi (plain)"

   128

   129

    # parameters

   130

    html_fixedwidth = True

   131

   132

    def format_html (self, lines, full_timestamps=False) :

   133

        """

   134

            Just uses format_txt, but processes links, etc

   135

        """

   136

   137

        # format using IrssiTextFormatter

   138

        for line, txt in self.format_txt(lines, full_timestamps) :

   139

            # escape HTML

   140

            html = xml.sax.saxutils.escape(txt)

   141

   142

            # process links

   143

            html = self._process_links(html)

   144

   145

            # yield

   146

            yield line, html

   147

   148

# define formatters by name

   149

FORMATTERS = {

   150

    'irssi':        IrssiFormatter,

   151

}

   152

   153

def by_name (name) :

   154

    """

   155

        Lookup and return a class LogFormatter by name

   156

    """

   157

   158

    return FORMATTERS[name]

   159