webroar 0.2.2

data/src/ruby_lib/profiler/instrumentation/active_record.rb

@@ -0,0 +1,48 @@
+# WebROaR - Ruby Application Server - http://webroar.in/
+# Copyright (C) 2009  WebROaR
+#
+# This file is part of WebROaR.
+#
+# WebROaR is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# WebROaR is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with WebROaR.  If not, see <http://www.gnu.org/licenses/>.
+
+module Webroar
+  module Profiler
+    trace_database_method(:find, ActiveRecord::Base, 'c')
+    trace_database_method(:delete_all, ActiveRecord::Base, 'c')
+    trace_database_method(:save, ActiveRecord::Base, 'i')
+    trace_database_method(:destroy, ActiveRecord::Base, 'i')
+    
+    # Comment out following lines, if you not interested in detailed analysis of ActiveRecord Models
+#    exclude_list = [Object, ActiveRecord::Base]
+#    if defined? ActiveRecord::SessionStore::Session
+#      exclude_list << ActiveRecord::SessionStore::Session
+#    end
+#    ObjectSpace.each_object(Class) { |c|
+#      if c.ancestors.include?(ActiveRecord::Base)
+#        unless exclude_list.include?(c)
+#          puts "class = #{c.ancestors[0]}"        
+#          c.methods(false).each { |m|
+#            puts m
+#            trace_database_method(m.to_sym, c.ancestors[0], 'c')
+#          }
+#          c.instance_methods(false).each { |m|
+#            puts m
+#            trace_database_method(m.to_sym, c.ancestors[0], 'i')
+#          }
+#        end
+#      end
+#    }
+    
+  end # Profiler
+end # Webroar

data/src/ruby_lib/profiler/instrumentation/instrumentation.rb

@@ -0,0 +1,27 @@
+# WebROaR - Ruby Application Server - http://webroar.in/
+# Copyright (C) 2009  WebROaR
+#
+# This file is part of WebROaR.
+#
+# WebROaR is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# WebROaR is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with WebROaR.  If not, see <http://www.gnu.org/licenses/>.
+
+module Webroar
+  module Profiler
+    case $g_options["app_type"]
+    when 'rails'
+      require File.join(File.dirname(__FILE__), 'rails.rb')
+    end # case
+  end # Profiler
+end # Webroar
+

data/src/ruby_lib/profiler/instrumentation/rails.rb

@@ -0,0 +1,26 @@
+# WebROaR - Ruby Application Server - http://webroar.in/
+# Copyright (C) 2009  WebROaR
+#
+# This file is part of WebROaR.
+#
+# WebROaR is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# WebROaR is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with WebROaR.  If not, see <http://www.gnu.org/licenses/>.
+
+module Webroar
+  module Profiler
+    require File.join(File.dirname(__FILE__), 'action_controller.rb')
+    require File.join(File.dirname(__FILE__), 'active_record.rb')
+  end # Profiler
+end # Webroar
+
+

data/src/ruby_lib/profiler/message_dispatcher.rb

@@ -0,0 +1,94 @@
+# WebROaR - Ruby Application Server - http://webroar.in/
+# Copyright (C) 2009  WebROaR
+#
+# This file is part of WebROaR.
+#
+# WebROaR is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# WebROaR is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with WebROaR.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'singleton'
+require 'starling'
+require 'yaml'
+module Webroar
+  module Profiler
+    class MessageDispatcher
+      include Singleton
+      #MAX_ENTRY = 30000
+      def initialize
+        @app_name = $g_options["app_name"].freeze
+        @app_env = $g_options["environment"].freeze
+        filename = File.join($g_options["webroar_root"],'conf','server_internal_config.yml')
+        configuration = YAML.load(File.open(filename))["starling"]
+        host = configuration["host"]
+        port = configuration["port"]        
+        @server = %Q{#{host}:#{port}}.freeze
+        @starling = Starling.new(@server)
+        @profiler_queue = "#{configuration['profiler_queue_name']}".freeze       
+        @exception_queue = "#{configuration['exception_queue_name']}".freeze
+        @pid_queue = "#{configuration['pid_queue_name']}".freeze
+        @max_entry = configuration["max_queue_items"] || 10000
+        # Until an item is set into queue, stats(e.g. sizeof) of that queue is not available(after every time starling has been restarted).
+        @starling.set(@profiler_queue,{}) rescue nil
+        @starling.set(@exception_queue,{}) rescue nil
+        @starling.set(@pid_queue,{}) rescue nil
+      end
+
+      def log_spent_time(url_metric)
+        #TODO: map uri metric with process id instead of app_name
+        #Webroar.log_info("spent_time=#{url_metric[:controller_action][2]}")
+        url_metric.merge!({:message_type => 'url_metric', :app_name => @app_name})
+        send_entry(@profiler_queue, url_metric)
+      end
+
+      def send_pid()
+        rv = send_entry(@pid_queue, {:message_type => 'pid', :app_name => @app_name, :pid => Process.pid})
+        if rv
+          Webroar.log_info("PID #{Process.pid} sent on queue.")
+          $pid_sent = true
+        else
+          Webroar.log_info("Dispatching pid on queue failed.")
+          $pid_sent = false
+        end
+      end
+
+      def send_entry(queue, value)
+        begin
+          if @starling.sizeof(queue) < @max_entry
+            @starling.set(queue, value)
+            true
+          else
+            Webroar.log_info("Number of messages in #{queue} has exceeds limit of #{@max_entry}. Failed to set the message.")
+            false
+          end
+        rescue  MemCache::MemCacheError, Timeout::Error => e
+          Webroar.log_error("Dispatching message on queue:#{e}")
+          Webroar.log_error("#{e.backtrace.join("\n")}")
+          false
+        end          
+      end
+
+      def log_exception(exception_details)
+        exception_details[:app_name] = @app_name
+        exception_details[:app_env] = @app_env
+        send_entry(@exception_queue, exception_details)
+      end
+
+    end # MessageDispatcher
+    if MessageDispatcher.instance.send_pid()
+      Webroar.log_info("Profiling started.")
+    else
+      Webroar.log_info("Profiling did not started.")
+    end
+  end # Profiler
+end # Webroar
+

data/src/ruby_lib/profiler/webroar_profiling.rb

@@ -0,0 +1,202 @@
+# WebROaR - Ruby Application Server - http://webroar.in/
+# Copyright (C) 2009  WebROaR
+#
+# This file is part of WebROaR.
+#
+# WebROaR is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# WebROaR is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with WebROaR.  If not, see <http://www.gnu.org/licenses/>.
+
+module Webroar
+  module Profiler
+    # method_name (Symbol) : name of method to be traced
+    # parent_name (Constant) : module/class hierarchy in camelcase which contains the method
+    # method_type (String) : instance method or class method under parent
+    # execute (Hash) : hash having two options, one option is :before_call having code to be executed 
+    # before calling a method(method_name), usually it is initialization of data structures
+    # and second option is :after_call having code to be executed after returning from method(method_name), 
+    # usually it is filling spent_time in that method or determination of controller/action name.
+    def trace_method(method_name, parent_name, method_type,  execute={})
+      if method_name.to_s =~ /([=\]><~])$/
+        Webroar.log_info("Can not profile #{method_name.to_s}")
+        return
+      end
+      without_profile_name = "without_webroar_profiling_#{method_name}"
+      with_profile_name = "with_webroar_profiling_#{method_name}"
+      if defined? parent_name
+        patch = <<-EOL
+        def #{with_profile_name}(*args, &block)
+          #{execute[:before_call]}
+          t1 =  Time.now
+          result = #{without_profile_name}(*args, &block)
+          t2 = Time.now
+          spent_time = ( t2 - t1) * 1000 #converting into miliseconds. TODO: store seconds directly
+          #{execute[:after_call]}
+          result
+        end
+        #         TODO: preserve method visibility
+        alias #{without_profile_name} #{method_name}
+        alias #{method_name} #{with_profile_name}
+        #         if #{parent_name}.private_instance_methods().include?(#{without_profile_name})
+        #           private #{method_name}
+        #         end
+        EOL
+        
+        case parent_name.class.to_s
+        when 'Class'
+          case method_type
+          when 'i'
+            parent_name.class_eval(patch, __FILE__, __LINE__)
+          when 'c'
+            parent_name.instance_eval(patch, __FILE__, __LINE__)
+          end
+        when 'Module'
+          #p 'inside module'
+          parent_name.module_eval {patch }
+        end
+      else
+        raise NameError, "#{parent_name.inspect} is not a valid constant name!"
+      end
+    end #trace_method
+
+    # :perform_action is an entry point for every request in ActionController, and wraps execution of 
+    # controller/action + template rendering for it.
+    # :trace_perform_action_equivalent helps in tracing any such method.
+    # We will get total time spent in controller/action and name of controller, action with help of this method.
+    # It takes following arguments :
+    # method_name (Symbol) : name of method to be traced
+    # parent_name (Constant) : module/class hierarchy in camelcase which contains the method
+    # method_type  (String) : instance method or class method under parent
+    def trace_perform_action_equivalent(method_name, parent_name, method_type)
+      execute = Hash.new
+      code = <<-CODE
+      Thread.current[:webroar_profiler] = {:controller_action => [], :database => {}, :rendering => 0.0, :rendering_started => false, :wall_time=>nil, :db_metric_stack => [], :render_metric_stack => [] }
+      CODE
+      execute[:before_call] = code
+      code = <<-CODE
+      webroar_cp = self.class.controller_path
+      webroar_an = action_name           
+      Thread.current[:webroar_profiler][:controller_action] = [webroar_cp, webroar_an, spent_time]      
+      Thread.current[:webroar_profiler][:wall_time] = t2
+      Webroar::Profiler::MessageDispatcher.instance.log_spent_time(Thread.current[:webroar_profiler])
+      Thread.current[:webroar_profiler] = nil
+      CODE
+      # In :after_call, determining name of controller/action, time spent in that and sending 
+      # collected metric on messaging queue.
+      execute[:after_call] = code
+      trace_method(method_name, parent_name, method_type, execute)
+    end
+
+    # Through :render method, ActionController performs template rendering.
+    # :trace_render_equivalent helps in tracing any such method.
+    # We will get total time spent in rendering with help of this method.
+    # It takes following arguments :
+    # method_name (Symbol) : name of method to be traced
+    # parent_name (Constant) : module/class hierarchy in camelcase which contains the method
+    # method_type  (String) : instance method or class method under parent
+    def trace_render_equivalent(method_name, parent_name, method_type)
+      execute = Hash.new
+      code = <<-CODE
+      if Thread.current[:webroar_profiler]
+        Thread.current[:webroar_profiler][:rendering_started] = true
+        Thread.current[:webroar_profiler][:render_metric_stack].push(0.0)     
+      end
+      CODE
+      # One can very well make db calls from template rendering. To find out pure time spent in rendering, 
+      # a check has been kept to determine whether rendering is started or not, if started then, time for 
+      # that db call is deducted from rendering time. So, there can be negative number in rendering time.
+      # In spent_time variable we are geting time spent in rendering template, including db call made from 
+      # it, adding it instead of assigning, to rendering time to get pure rendering time.
+      # In Rails 2.2.2 there is *render* call, from *render* itself(i.e. recursive call for *render*). We 
+      # will count spent_time from the first *render* call only(which give total time in *render*, including 
+      # all recursive call)
+      execute[:before_call] = code
+      code = <<-CODE
+      if Thread.current[:webroar_profiler]           
+        metric_stack = Thread.current[:webroar_profiler][:render_metric_stack]        
+        metric_stack.pop      
+        unless metric_stack.size > 0
+          Thread.current[:webroar_profiler][:rendering] += spent_time    
+          Thread.current[:webroar_profiler][:rendering_started] = false  
+        end        
+      end
+      CODE
+      execute[:after_call] = code
+      trace_method(method_name, parent_name, method_type, execute)
+    end
+
+    # :trace_database_method helps in tracing ORM framework. Currently supporting ActiveRecord.
+    # It takes following arguments:
+    # method_name (Symbol) : name of method to be traced
+    # parent_name (Constant) : module/class hierarchy in camelcase which contains the method
+    # method_type  (String) : instance method or class method under parent
+    def trace_database_method(method_name, parent_name, method_type)
+      execute = Hash.new
+      # Session management can be done through ORM, a check(if Thread.current[:webroar_profiler]) has been kept to record spent time only if its been
+      # called from controller's method.
+      
+      # Method1 can call Method2, Method2 can call Method3 and so on..
+      # Stack helps in calculating exclusive time spent in each method
+      code = <<-CODE
+      if Thread.current[:webroar_profiler]                
+        db_metric_stack = Thread.current[:webroar_profiler][:db_metric_stack]
+        db_metric_stack.push(0.0)
+        Thread.current[:webroar_profiler][:db_metric_stack] = db_metric_stack      
+      end
+      CODE
+      execute[:before_call] = code
+      if method_type == 'c'
+        class_name_key = "key = self.name"
+      else
+        class_name_key = "key = self.class.name"
+      end
+      # converting method_name(symbol) into string, to make it work as key, and not a method call
+      method_name_key = "'"+method_name.to_s+"'"
+#      puts caller.join("\n")   #left over for debugging
+#      Checking rendering flag, and deducting db time from rendering time to get pure rendering time.     
+#      stack is used to cover following method call-chain possibilities 
+#      (I) )A->B->C (II) A->B, A->C->D 
+      code = <<-CODE
+      if Thread.current[:webroar_profiler]
+        #{class_name_key}                
+        db_hash = Thread.current[:webroar_profiler][:database]
+        db_metric_stack = Thread.current[:webroar_profiler][:db_metric_stack]        
+        pop1_time = db_metric_stack.pop
+        record_time = spent_time - pop1_time
+        if db_metric_stack.size > 0
+          pop2_time = db_metric_stack.pop
+          db_metric_stack.push(spent_time + pop2_time)
+        end        
+        unless db_hash[#{method_name_key}]
+          db_hash[#{method_name_key}] = Hash.new
+        end
+        if db_hash[#{method_name_key}][key]
+          db_hash[#{method_name_key}][key] += record_time
+        else
+          db_hash[#{method_name_key}][key] = record_time
+        end
+        Thread.current[:webroar_profiler][:database] = db_hash
+        if Thread.current[:webroar_profiler][:rendering_started] == true
+          Thread.current[:webroar_profiler][:rendering] -= record_time
+        end
+      end
+      CODE
+      execute[:after_call] = code
+      trace_method(method_name, parent_name, method_type, execute)
+    end
+
+    module_function(:trace_method, :trace_perform_action_equivalent, :trace_render_equivalent, :trace_database_method)
+  end #Profiler
+end #Webroar
+
+require File.expand_path(File.join($g_options["webroar_root"], 'src', 'ruby_lib', 'profiler', 'instrumentation', 'instrumentation.rb'))
+

data/src/ruby_lib/rack/adapter/rack.rb

@@ -0,0 +1,62 @@
+# WebROaR - Ruby Application Server - http://webroar.in/
+# Copyright (C) 2009  WebROaR
+#
+# This file is part of WebROaR.
+#
+# WebROaR is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# WebROaR is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with WebROaR.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'rubygems'
+require 'rack'
+
+module Webroar  
+  module Adapter     
+    class Rack
+      def initialize(options={})
+        @root = options['root'].freeze           
+        @prefix_regexp = Regexp.new((options['prefix'] || '/')).freeze
+        ENV['APP_ROOT'] = options['root']
+        ENV['APP_ENV'] = options["environment"]
+        ENV['APP_BASE_URI'] = options["prefix"] || '/'
+        @file_server = ::Rack::File.new(::File.join(@root, "public"))
+        Dir.chdir(@root) # Some application uses current directory to map other files.
+  	    $0 = 'webroar' # Some application using it to retrive executable name.
+        cfgfile = ::File.read('config.ru')
+        @app = eval("::Rack::Builder.new {( " + cfgfile + "\n )}.to_app", nil, 'config.ru')
+      end
+      
+      def file_exist?(path)
+        full_path = ::File.join(@file_server.root, ::Rack::Utils.unescape(path))	
+        ::File.file?(full_path) && ::File.readable?(full_path)
+      end
+    
+      def serve_file(env)
+        @file_server.call(env)
+      end
+    
+      def call(env)
+        match = @prefix_regexp.match(env[Webroar::REQUEST_PATH])         
+    	  env[Webroar::SCRIPT_NAME] = match.to_s         
+        env[Webroar::PATH_INFO] = env[Webroar::REQUEST_PATH] = match.post_match
+  	    path = env[Webroar::PATH_INFO].chomp(Webroar::SLASH)				
+    	  if file_exist?(path)              # Serve the file if it's there
+          serve_file(env)
+    	  else				# TODO: Serve cached page
+    	    @app.call(env)
+    	  end
+      end
+    end  
+  end
+
+end
+      

data/src/ruby_lib/rack/adapter/rails.rb

@@ -0,0 +1,185 @@
+require 'cgi'
+require 'rubygems'
+require 'rack'
+#require 'ruby-debug' #for debugging
+#Debugger.start #for debugging
+
+# Adapter to run a Rails app with any supported Rack handler.
+# By default it will try to load the Rails application in the
+# current directory in the development environment.
+# Options:
+#  root: Root directory of the Rails app
+#  env: Rails environment to run in (development, production or test)
+# Based on http://fuzed.rubyforge.org/ Rails adapter
+module Webroar 
+  module Adapter 
+    class Rails
+      
+      def initialize(options={})		
+        # TODO: Keys are strings setup in C, check how to setup as symbols        
+        @root   = (options["root"]         || Dir.pwd).freeze         
+        @env    = (options["environment"]  || 'development').freeze         
+        @prefix = (options["prefix"] || '/').freeze         
+        @prefix_regexp = Regexp.new(@prefix).freeze                
+        Dir.chdir(options["root"]) # Some application uses current directory to map other files.
+        $0 = 'webroar' # Some application using it to retrive executable name.
+        load_application
+        
+        @rails_app = if defined?(ActionController::Dispatcher) and ActionController::Dispatcher.instance_methods.include?('call')
+          ActionController::Dispatcher.new
+        else
+          CgiApp.new
+        end
+        
+        @file_server = ::Rack::File.new(::File.join(RAILS_ROOT, "public"))
+      end
+      
+      def load_application
+        ENV['RAILS_ENV'] = @env
+        
+        require "#{@root}/config/environment"
+        require 'dispatcher'        
+        if ActionController::Base.respond_to?('relative_url_root=') 
+          ActionController::Base.relative_url_root = @prefix # new way to set the relative URL in Rails 2.1.1 
+        else 
+          ActionController::AbstractRequest.relative_url_root = @prefix
+        end 
+      end
+      
+      # TODO refactor this in File#can_serve?(path) ??
+      def file_exist?(path)
+        full_path = ::File.join(@file_server.root, ::Rack::Utils.unescape(path))	
+        ::File.file?(full_path) && ::File.readable?(full_path)
+      end
+      
+      def serve_file(env)
+        @file_server.call(env)
+      end
+      
+      def call(env)
+        #following three lines are copied from mongrel to resolve prefix issue.         
+        match = @prefix_regexp.match(env[Webroar::REQUEST_PATH])         
+        env[Webroar::SCRIPT_NAME] = match.to_s         
+        env[Webroar::PATH_INFO] = match.post_match    
+        path        = env[Webroar::PATH_INFO].chomp(Webroar::SLASH)
+        cached_path = (path.empty? ? Webroar::INDEX : path) + ActionController::Base.page_cache_extension
+        
+        if file_exist?(path)              # Serve the file if it's there
+          serve_file(env)
+        elsif file_exist?(cached_path)    # Serve the page cache if it's there
+          env[Webroar::PATH_INFO] = cached_path
+          serve_file(env)
+        else                              # No static file, let Rails handle it
+          @rails_app.call(env)
+        end
+      end      
+      
+      protected
+      
+      # For Rails pre Rack (2.3)
+      class CgiApp
+        def call(env)
+          #debugger #for debugging
+          request         = ::Rack::Request.new(env)
+          response        = ::Rack::Response.new
+          
+          session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS
+          cgi             = CGIWrapper.new(request, response)
+          
+          Dispatcher.dispatch(cgi, session_options, response)
+          
+          response.finish          
+        end
+      end
+      
+      class CGIWrapper < ::CGI
+        def initialize(request, response, *args)
+          @request  = request
+          @response = response
+          @args     = *args
+          @input    = request.body
+          
+          super *args
+        end
+        
+        def header(options = "text/html")
+          if options.is_a?(String)
+            @response['Content-Type']     = options unless @response['Content-Type']
+          else
+            @response['Content-Length']   = options.delete('Content-Length').to_s if options['Content-Length']
+            
+            @response['Content-Type']     = options.delete('type') || "text/html"
+            @response['Content-Type']    += "; charset=" + options.delete('charset') if options['charset']
+            
+            @response['Content-Language'] = options.delete('language') if options['language']
+            @response['Expires']          = options.delete('expires') if options['expires']
+            
+            @response.status              = options.delete('Status') if options['Status']
+            
+            # Convert 'cookie' header to 'Set-Cookie' headers.
+            # Because Set-Cookie header can appear more the once in the response body, 
+            # we store it in a line break seperated string that will be translated to
+            # multiple Set-Cookie header by the handler.
+            if cookie = options.delete('cookie')
+              cookies = []
+              
+              case cookie
+              when Array then cookie.each { |c| cookies << c.to_s }
+              when Hash  then cookie.each { |_, c| cookies << c.to_s }
+              else            cookies << cookie.to_s
+              end
+              
+              @output_cookies.each { |c| cookies << c.to_s } if @output_cookies
+              
+              @response['Set-Cookie'] = [@response['Set-Cookie'], cookies].compact
+              # See http://groups.google.com/group/rack-devel/browse_thread/thread/e8759b91a82c5a10/a8dbd4574fe97d69?#a8dbd4574fe97d69                
+              if RUBY_VERSION =~ /^1\.8/
+                @response['Set-Cookie'].flatten!
+              else
+                @response['Set-Cookie'] = @response['Set-Cookie'].join("\n")
+              end         
+              
+            end
+            
+            options.each { |k,v| @response[k] = v }
+          end
+          
+            ""
+        end
+        
+        def params
+          @params ||= @request.params
+        end
+        
+        def cookies
+          @request.cookies
+        end
+        
+        def query_string
+          @request.query_string
+        end
+        
+        # Used to wrap the normal args variable used inside CGI.
+        def args
+          @args
+        end
+        
+        # Used to wrap the normal env_table variable used inside CGI.
+        def env_table
+          @request.env
+        end
+        
+        # Used to wrap the normal stdinput variable used inside CGI.
+        def stdinput
+          @input
+        end
+        
+        def stdoutput
+          STDERR.puts "stdoutput should not be used."
+          @response.body
+        end
+      end
+    end
+  end
+
+end