| Andrew Cooke | Contents | Latest | RSS | Twitter | Previous | Next

C[omp]ute

Welcome to my blog, which was once a mailing list of the same name and is still generated by mail. Please reply via the "comment" links.

Always interested in offers/projects/new ideas. Eclectic experience in fields like: numerical computing; Python web; Java enterprise; functional languages; GPGPU; SQL databases; etc. Based in Santiago, Chile; telecommute worldwide. CV; email.

Personal Projects

Lepl parser for Python.

Colorless Green.

Photography around Santiago.

SVG experiment.

Professional Portfolio

Calibration of seismometers.

Data access via web services.

Cache rewrite.

Extending OpenSSH.

Last 100 entries

NSA Interceptng Gmail During Delivery; General IIR Filters; What's happening with Scala?; Interesting (But Largely Illegible) Typeface; Retiring Essentialism; Poorest in UK, Poorest in N Europe; I Want To Be A Redneck!; Reverse Racism; The Lost Art Of Nomography; IBM Data Center (Photo); Interesting Account Of Gamma Hack; The Most Interesting Audiophile In The World; How did the first world war actually end?; Ky - Restaurant Santiago; The Black Dork Lives!; The UN Requires Unaninmous Decisions; LPIR - Steganography in Practice; How I Am 6; Clear Explanation of Verizon / Level 3 / Netflix; Teenage Girls; Formalising NSA Attacks; Switching Brakes (Tektro Hydraulic); Naim NAP 100 (Power Amp); AKG 550 First Impressions; Facebook manipulates emotions (no really); Map Reduce "No Longer Used" At Google; Removing RAID metadata; New Bike (Good Bike Shop, Santiago Chile); Removing APE Tags in Linux; Compiling Python 3.0 With GCC 4.8; Maven is Amazing; Generating Docs from a GitHub Wiki; Modular Shelves; Bash Best Practices; Good Emergency Gasfiter (Santiago, Chile); Readings in Recent Architecture; Roger Casement; Integrated Information Theory (Or Not); Possibly undefined macro AC_ENABLE_SHARED; Update on Charges; Sunburst Visualisation; Spectral Embeddings (Distances -> Coordinates); Introduction to Causality; Filtering To Help Colour-Blindness; ASUS 1015E-DS02 Too; Ready Player One; Writing Clear, Fast Julia Code; List of LatAm Novels; Running (for women); Building a Jenkins Plugin and a Jar (for Command Line use); Headphone Test Recordings; Causal Consistency; The Quest for Randomness; Chat Wars; Real-life Financial Co Without ACID Database...; Flexible Muscle-Based Locomotion for Bipedal Creatures; SQL Performance Explained; The Little Manual of API Design; Multiple Word Sizes; CRC - Next Steps; FizzBuzz; Update on CRCs; Decent Links / Discussion Community; Automated Reasoning About LLVM Optimizations and Undefined Behavior; A Painless Guide To CRC Error Detection Algorithms; Tests in Julia; Dave Eggers: what's so funny about peace, love and Starship?; Cello - High Level C Programming; autoreconf needs tar; Will Self Goes To Heathrow; Top 5 BioInformatics Papers; Vasovagal Response; Good Food in Vina; Chilean Drug Criminals Use Subsitution Cipher; Adrenaline; Stiglitz on the Impact of Technology; Why Not; How I Am 5; Lenovo X240 OpenSuse 13.1; NSA and GCHQ - Psychological Trolls; Finite Fields in Julia (Defining Your Own Number Type); Julian Assange; Starting Qemu on OpenSuse; Noisy GAs/TMs; Venezuela; Reinstalling GRUB with EFI; Instructions For Disabling KDE Indexing; Evolving Speakers; Changing Salt Size in Simple Crypt 3.0.0; Logarithmic Map (Moved); More Info; Words Found in Voynich Manuscript; An Inventory Of 3D Space-Filling Curves; Foxes Using Magnetic Fields To Hunt; 5 Rounds RC5 No Rotation; JP Morgan and Madoff; Ori - Secure, Distributed File System; Physical Unclonable Functions (PUFs); Prejudice on Reddit; Recursion OK; Optimizing Julia Code

© 2006-2013 Andrew Cooke (site) / post authors (content).

A Python Logging Service

From: andrew cooke <andrew@...>

Date: Sun, 22 Aug 2010 17:01:28 -0400

I've been lookng at Twisted, which is a framework for cooperative
multi-tasking in Python.  I don't find that a very useful description, so here
are two alternatives:

1 - It's a way of structuring multi-threaded programs that's a lot more like
    Javascript or GUI toolkits.

2 - It's a way of writing network servers that work efficiently without using
    multiple threads.


There's a fair amount of documentation at
http://twistedmatrix.com/documents/current/core/ (and most imporantly at
http://twistedmatrix.com/documents/current/core/howto/index.html ) - I suggest
reading through that until it sticks.  It took me a while, and writing the
code below, but now it makes a lot of sense (and it seems like a very nicely
engineered system).


I structured the example below as a set of different files, which was probably
excessive, but I wanted the difference components to be as clear as possible.

Python logging can be serialised over a socket.  This code in a server that
receives seralised messages and writes them to a log.


First, the protocol:

  from cPickle import loads
  from logging import makeLogRecord, getLogger
  from struct import unpack
  from twisted.internet.protocol import Protocol, connectionDone

  '''
  The protocol for a Twisted server that receives log messages.

  See http://docs.python.org/library/logging.html#socket-handler 
  '''

  class LoggingProtocol(Protocol):

      def dataReceived(self, data):
	  self.__data += data
	  while True:
	      if not self.__message_len and len(self.__data) >= 4:
		  # unpack length prefix
		  self.__message_len = unpack(">L", self.__data[:4])[0]
		  self.__data = self.__data[4:]
	      if self.__message_len and len(self.__data) >= self.__message_len:
		  # unpack message
		  record =
	  makeLogRecord(loads(self.__data[0:self.__message_len]))
		  self.__data = self.__data[self.__message_len:]
		  self.__message_len = 0
		  logger = getLogger(record.name)
		  logger.handle(record)
	      else:
		  break

      def connectionMade(self):
	  self.__data = ''
	  self.__message_len = 0

      def connectionLost(self, reason=connectionDone):
	  self.__data = None
	  self.__message_len = None


Next, the factory (ie a protocol factory):

  from logging.config import dictConfig
  from twisted.internet.protocol import Factory

  from log.protocol import LoggingProtocol

  '''
  A factory for the remote Python logger.

  This seems to be the best location to store configuration information because
  it is accessible both in tests (using a reactor) and to an application.
  '''

  class LoggingFactory(Factory):

      protocol = LoggingProtocol

      DEFAULT_PORT = 2000
      DEFAULT_CONFIG = {'version': 1,
			'handlers':
			  {'file':
			    {'class': 'logging.FileHandler',
			     'filename': 'logging-service.log',
			     'level': 'DEBUG',
			  },},
			'root':
			  {'level': 'DEBUG',
			   'handlers': ['file']},}

      def __init__(self, config_dict=None):
	  if not config_dict:
	      config_dict = self.DEFAULT_CONFIG
	  dictConfig(config_dict)


And the service:

  from twisted.application.internet import TCPServer

  from log.factory import LoggingFactory

  '''
  A service for the remote Python logger.

  This is used by the application.
  '''

  class LoggingService(TCPServer):

      def __init__(self, port=None, config_dict=None, interface='0.0.0.0'):
	  if not port:
	      port = LoggingFactory.DEFAULT_PORT
	  # old style clases in twisted
	  TCPServer.__init__(self, port, LoggingFactory(config_dict), 
			     interface=interface)


This can then be made into an application (a daemon) that's run from the
command-line using a tool called "twistd":

  # You can run this .tac file directly with:
  #    twistd -ny service.tac

  from log.service import LoggingService
  from twisted.application import service

  application = service.Application("Logging application")
  LoggingService().setServiceParent(application)


Alternatively, for testing, the Fatcory can be used directly.  This test code
also gives a glimpse of how the reactor is used to schedule events (there's
also an abstraction for chaining callbacks called "Defered"):

  from logging.config import dictConfig
  from logging import getLogger
  from multiprocessing.process import Process
  from tempfile import mkstemp
  from twisted.internet import reactor
  from unittest import TestCase

  from log.factory import LoggingFactory


  class LoggingTest(TestCase):
      '''
      Test the logging service by starting an instance, then firing up a 
      separate process that logs to the service.
      '''

      def test_logging(self):
	  tick = Tick()
	  (_fd, self.tmp) = mkstemp()
	  process = Process(target=self.logging_process)
	  factory = LoggingFactory({'version': 1,
				    'handlers': {'file': {'class': 'logging.FileHandler',
							  'filename': self.tmp,
							  'level': 'DEBUG'}},
				    'root': {'level': 'DEBUG',
					     'handlers': ['file']}})
	  reactor.listenTCP(factory.DEFAULT_PORT, factory)
	  reactor.callLater(tick(), process.start)
	  reactor.callLater(tick(), reactor.stop)
	  reactor.run()
	  fd = open(self.tmp)
	  contents = fd.readlines()
	  assert contents == ['a warning\n'], contents
	  fd.close()

      def logging_process(self):
	  dictConfig({'version': 1,
		      'handlers':
			{'socket':
			  {'class': 'logging.handlers.SocketHandler',
			   'level': 'INFO',
			   'host': 'localhost',
			   'port': LoggingFactory.DEFAULT_PORT
			   },},
		      'root':
			{'level': 'INFO',
			 'handlers': ['socket']},
		     })
	  logger = getLogger('test')
	  logger.debug('a debug') # discarded by "level: INFO" above
	  logger.warn('a warning')


  class Tick(object):

      def __init__(self, increment=0.1):
	  self.__increment = increment
	  self.__time = 0

      def __call__(self, step=1):
	  self.__time += step * self.__increment
	  return self.__time


Andrew

Comment on this post