Counting the number of requests per second in Tornado

Question

I am new to Python and Tornado WebServer. I am trying to figure out the number of request and number of requests/second in my server side code. I am using Tornadio2 to implement websockets.

Kindly take a look at the following code and let me know, what modification can be done to it. I am using the RequestHandler.prepare() to bottleneck all the requests and using a list as it is immutable to store the count.

Consider all modules are included

    count=[0]
    class IndexHandler(tornado.web.RequestHandler):
     """Regular HTTP handler to serve the chatroom page"""
       def prepare(self):
       count[0]=count[0]+1

       def get(self):
         self.render('index1.html')

   class SocketIOHandler(tornado.web.RequestHandler):
      def get(self):
         self.render('../socket.io.js')

  partQue=Queue.Queue()
  class ChatConnection(tornadio2.conn.SocketConnection):
        participants = set()
        def on_open(self, info):
           self.send("Welcome from the server.")
           self.participants.add(self)     

       def on_message(self, message):
            partQue.put(message)
            time.sleep(10)
            self.qmes=partQue.get()
            for p in self.participants:
                p.send(self.qmes+" "+str(count[0]))
            partQue.task_done()   

      def on_close(self):
           self.participants.remove(self)
           partQue.join()

 # Create tornadio server
  ChatRouter = tornadio2.router.TornadioRouter(ChatConnection)

 # Create socket application
  sock_app = tornado.web.Application(
      ChatRouter.urls, 
      flash_policy_port = 843,
      flash_policy_file = op.join(ROOT, 'flashpolicy.xml'),
      socket_io_port = 8002)

 # Create HTTP application
 http_app = tornado.web.Application(
      [(r"/", IndexHandler), (r"/socket.io.js", SocketIOHandler)])

 if __name__ == "__main__":
     import logging
     logging.getLogger().setLevel(logging.DEBUG)

     # Create http server on port 8001
     http_server = tornado.httpserver.HTTPServer(http_app)
     http_server.listen(8001)

     # Create tornadio server on port 8002, but don't start it yet
     tornadio2.server.SocketServer(sock_app, auto_start=False)

     # Start both servers
     tornado.ioloop.IOLoop.instance().start()

Also, I am confused about every Websocket messages. Does each Websocket event got to server in the form of an HTTP request? or a Socket.IO request?

Answer 1

I use Siege - excellent tool for testing requests if your running on linux. Example

siege http://localhost:8000/?q=yourquery -c10 -t10s 

-c10 = 10 concurrent users -t10s = 10 seconds

Answer 2

Tornadio2 has built-in statistics module, which includes incoming connections/s and other counters.

Check following example: https://github.com/MrJoes/tornadio2/tree/master/examples/stats

Answer 3

When testing applications, always approach performance testing with a healthy appreciation for the uncertainty principle. .

If you want to test a server, hook up two PCs to a HUB where you can monitor traffic from one going to the other. Then bang the hell out of the server. There are a variety of tools for doing this, just look for web load testing tools.

Answer 4

Normal HTTP requests in Tornado create a new RequestHandler instance, which persists until the connection is terminated.

WebSockets use persistent connections. One WebSocketHandler instance is created, and each message sent by the browser to the server calls the on_message method.

From what I understand, Socket.IO/Tornad.IO will use WebSockets if supported by the browser, falling back to long polling.