How to use the twisted.python.log function in Twisted

def addBuild(buildstatus):
  try:
    b = Build(buildstatus)
  except Exception, e:
    log.msg("Creating build database object raised " + str(e))
    return
  session.save(b)
  session.commit()
  # check if we need to add this to our active table
  aq = session.query(Active)
  if aq.filter_by(**b.dict()).count():
    # we already have this one
    return
  a = Active(b)
  session.save(a)
  session.commit()

def force_shutdown():
                log.msg("Reactor didn't stop cleanly, doing unclean shutdown.")
                os._exit(0)
            reactor.callLater(2.0, force_shutdown)

message = argv[2]

            bot = FakeBot()

            brain = Brain(bot, [BrbMatcher(), SifterMatcher(), GifterMatcher(),
                JenkinsMatcher(), VolunteerMatcher(), TimezoneMatcher(),
                PointsMatcher(), SillyMatcher()])

            brain.set_channel(None)

            brain.handle('', message, 'le-user')

        sys.exit(1)

    # initialize logging
    log.startLogging(sys.stdout)

    # create factory protocol and application
    room = os.environ.get('ROOM')
    if not room:
        room = sys.argv[1]
    f = LogBotFactory(room)

    # connect factory to this host and port
    reactor.connectTCP("irc.freenode.net", 6667, f)

    # run bot
    reactor.run()

def strict(avatar, resource, action, acls):
    """Only allows operation if a user has the corresponding bit set"""
    log.msg("Strict authorization of %s to perform %s on %s. ACLs: %s" %
            (avatar, action, resource, acls))
    if resource == '/':
        return avatar != 'Anonymous'  # for / resource we expect a real user name
    if acls is None:
        return False  # disallowed by default
    for prefix in ['read', 'write', 'delete']:
        if action.startswith(prefix):
            user_acls = acls.get(avatar)
            if user_acls is None:
                return False  # disallowed by default
            return rights[prefix] in user_acls
    return False

def quirkyMessage(self, s):
        """
        This is called when I receive a message which is peculiar, but not
        wholly indecipherable.

        @param s: The peculiar message.
        @type s: L{bytes}
        """
        log.msg(s + '\n')

def handle_inbound_dm(self, dm):
        if self.is_own_dm(dm):
            log.msg("Received own DM on user stream: %r" % (dm,))
        elif 'dms' not in self.endpoints:
            log.msg(
                "Discarding DM received on user stream, no endpoint "
                "configured for DMs: %r" % (dm,))
        else:
            log.msg("Received DM on user stream: %r" % (dm,))
            self.publish_dm(dm)

def __init__(self, name='unknown gst-source', pipeline="audiotestsrc ! audioconvert ! lame ! ffmux_mpegts ! appsink name=\"sink\""):
        super(GstInlet, self).__init__(name=name)
        self.pipeline = pipeline
        log.msg("initializing", system=self.name)

unregistered, which should result in streaming stopping.
        """
        while True:
            try:
                self._producer.resumeProducing()
            except:
                log.err(None, "%s failed, producing will be stopped:" %
                        (safe_str(self._producer),))
                try:
                    self._consumer.unregisterProducer()
                    # The consumer should now call stopStreaming() on us,
                    # thus stopping the streaming.
                except:
                    # Since the consumer blew up, we may not have had
                    # stopStreaming() called, so we just stop on our own:
                    log.err(None, "%s failed to unregister producer:" %
                            (safe_str(self._consumer),))
                    self._finished = True
                    return
            yield None

def _pinger(self):
        """
        Regular 'ping' service.

        We send 'pings' to other end of RTMP protocol, expecting to receive
        'pong'. If we receive some data, we assume 'ping' is sent. If other end
        of protocol doesn't send anything in reply to our 'ping' for some timeout,
        we disconnect connection.
        """
        noDataInterval = _time.seconds() - self.lastReceived

        if noDataInterval > config.getint('RTMP', 'keepAliveTimeout'):
            log.msg('Closing connection due too much inactivity (%d)' % noDataInterval)
            self.transport.loseConnection()
            return

        if noDataInterval > config.getint('RTMP', 'pingInterval'):
            self.pushPacket(Ping(Ping.PING_CLIENT, [int(_time.seconds()*1000) & 0x7fffffff]))

        self.pushPacket(BytesRead(self.bytesReceived))

def _do_disable_device(self):
        self.clean_signals()

        if self.device.status == MM_MODEM_STATE_CONNECTED:

            def on_disconnect_from_internet(_):
                if self.device.status >= MM_MODEM_STATE_REGISTERED:
                    self.device.set_status(MM_MODEM_STATE_REGISTERED)
                self.device.close()

            d = self.disconnect_from_internet()
            d.addCallback(on_disconnect_from_internet)
            d.addErrback(log.err)
            return d

        if self.device.status >= MM_MODEM_STATE_ENABLED:
            self.device.close()

        return defer.succeed(None)