Running with Ruby

Tag: safety (page 1 of 4)

Simple Ruby(Rails) Passenger memory consumption limit monitoring

Apache Passenger is quite nice for smaller applications (or on a server with multiply apps). It is easy to deploy, maintain and upgrade. However it has also some limitations. For example we cannot set max memory consumption limit. We can set PassengerMaxRequests limit – so each Passenger instance will be killed after N requests, but this won’t help us, when Passenger instance suddenly get really big (150 and more MB).

If you use MRI instead of REE on production, you can encounter this issue. Standard small app worker should consume around 75-125MB of memory. But sometimes, something goes crazy and they start to grow rapidly until they reach memory limit. After that, server starts to respond really slow (or stop responding).

Passenger memory status to the rescue!

What can we do, to protect against such situations? First of all, we can monitor Passenger memory consumption with command passenger-memory-stats. The output should look like this:

---------- Apache processes ----------
PID    PPID   VMSize    Private  Name
1437   15768  178.1 MB  0.6 MB   /usr/sbin/apache2 -k start
3415   15768  178.0 MB  0.7 MB   /usr/sbin/apache2 -k start
3417   15768  178.1 MB  1.0 MB   /usr/sbin/apache2 -k start
4345   15768  178.1 MB  0.7 MB   /usr/sbin/apache2 -k start
4346   15768  178.2 MB  1.2 MB   /usr/sbin/apache2 -k start
4352   15768  178.1 MB  0.8 MB   /usr/sbin/apache2 -k start
4546   15768  178.0 MB  0.5 MB   /usr/sbin/apache2 -k start
4628   15768  178.1 MB  1.2 MB   /usr/sbin/apache2 -k start
4664   15768  178.1 MB  0.5 MB   /usr/sbin/apache2 -k start
4669   15768  178.2 MB  0.7 MB   /usr/sbin/apache2 -k start
4796   15768  178.1 MB  0.7 MB   /usr/sbin/apache2 -k start
5362   15768  177.7 MB  0.5 MB   /usr/sbin/apache2 -k start
6195   15768  178.0 MB  0.7 MB   /usr/sbin/apache2 -k start
6208   15768  209.3 MB  32.4 MB  /usr/sbin/apache2 -k start
6211   15768  178.0 MB  0.6 MB   /usr/sbin/apache2 -k start
6213   15768  177.6 MB  0.3 MB   /usr/sbin/apache2 -k start
6214   15768  178.0 MB  0.9 MB   /usr/sbin/apache2 -k start
6256   15768  201.7 MB  25.9 MB  /usr/sbin/apache2 -k start
6257   15768  177.9 MB  0.8 MB   /usr/sbin/apache2 -k start
6353   15768  177.5 MB  0.2 MB   /usr/sbin/apache2 -k start
15768  1      177.5 MB  0.1 MB   /usr/sbin/apache2 -k start
### Processes: 21
### Total private dirty RSS: 70.92 MB

-------- Nginx processes --------
### Processes: 0
### Total private dirty RSS: 0.00 MB

----- Passenger processes ------
PID    VMSize    Private   Name
1643   901.9 MB  105.0 MB  Rails: /rails/app/current
1658   900.6 MB  103.3 MB  Rails: /rails/app/current
3425   898.4 MB  95.4 MB   Rails: /rails/app/current
6323   874.2 MB  49.5 MB   Passenger ApplicationSpawner: /rails/app/current
6409   887.7 MB  62.9 MB   Rails: /rails/app/current
15775  22.9 MB   0.3 MB    PassengerWatchdog
15778  164.5 MB  2.6 MB    PassengerHelperAgent
15780  43.1 MB   7.0 MB    Passenger spawn server
15783  136.9 MB  0.7 MB    PassengerLoggingAgent
32082  961.7 MB  126.9 MB  Rails: /rails/app/current
### Processes: 10
### Total private dirty RSS: 553.53 MB

We are particularly interested in Passenger processes section. To see just PID and MB consumption of all the workers, we could filter out unneeded data:

passenger-memory-stats | grep Rails:\ /home  | awk ' { print $1 " - " $4}'

So the output would look like this:

1643 - 105.0
1658 - 106.9
3425 - 99.1
6409 - 70.7
8381 - 0.1
32082 - 130.3

So now we can have a quick overview on how our server is doing.

I’m to lazy! I don’t want to check it all the time. This should monitor itself!

It is quite obvious, that monitoring should be done in an automatic way. Of course it is recommended to check Passenger stats from time to time, but who would monitor and kill bloated Passenger workers on his one? Probably no one. That’s why, we’re gonna create a simple Ruby program, to monitor and shutdown gracefully (or kill if they don’t want to shutdown) Passenger workers.

How to kill Passenger processes from Ruby?

Each Passenger instance is a separate process and it has it’s own PID. Killing processes from Ruby is really easy. We do this by executing following command:

Process.kill(signal, pid)

We will use this method and try to kill Passenger processes gracefully (gracefully means that Passenger process will complete any request that it is performing right now and will shutdown). If this fails, we will send a TERM signal and kill it instantaneously.

  • SIGUSR1 signal – shutdown gracefully
  • TERM signal – kill it instantaneously

Final Ruby monitoring

Ok, so now we know how to kill Passenger process, there rest is simple – we need to extract PID and memory usage, set a limit, check it and kill every instance that exceeds this limit:

# Finds bloating passengers and try to kill them gracefully.
# @example:
require 'logger'

class PassengerMonitor
  # How much memory (MB) single Passenger instance can use
  # Log file name
  DEFAULT_LOG_FILE = 'passenger_monitoring.log'
  # How long should we wait after graceful kill attempt, before force kill
  WAIT_TIME = 10

  def = {})

  # Set up memory limit, log file and logger
  def initialize(params = {})
    @memory_limit = params[:memory_limit] || DEFAULT_MEMORY_LIMIT
    @log_file = params[:log_file] || DEFAULT_LOG_FILE
    @logger =

  # Check all the Passenger processes
  def check 'Checking for bloated Passenger workers'

    `passenger-memory-stats`.each_line do |line|
next unless (line =~ /RackApp: / || line =~ /Rails: /)

      pid, memory_usage =  extract_stats(line)

      # If a given passenger process is bloated try to
      # kill it gracefully and if it fails, force killing it
      if bloated?(pid, memory_usage)
        kill!(pid) if process_running?(pid)
    end 'Finished checking for bloated Passenger workers'


  # Check if a given process is still running
  def process_running?(pid)
    Process.getpgid(pid) != -1
  rescue Errno::ESRCH

  # Wait for process to be killed
  def wait
    @logger.error "Waiting for worker to shutdown..."

  # Kill it gracefully
  def kill(pid)
    @logger.error "Trying to kill #{pid} gracefully..."
    Process.kill("SIGUSR1", pid)

  # Kill it with fire
  def kill!(pid)
    @logger.fatal "Force kill: #{pid}"
    Process.kill("TERM", pid)

  # Extract pid and memory usage of a single Passenger
  def extract_stats(line)
    stats = line.split
    return stats[0].to_i, stats[3].to_f

  # Check if a given process is exceeding memory limit
  def bloated?(pid, size)
    bloated = size > @memory_limit
    @logger.error "Found bloated worker: #{pid} - #{size}MB" if bloated


Source code is easy and it has comments so there is no need for further explanations. Usage is reduced to just one line:

How to incorporate it into your Rails project and run it from cron?

Using this with your Rails app is really easy. First of all copy-paste the the source code from above and put it in /lib dir of your project, in a file called passenger_monitor.rb.

Then, create a file in /scripts named passenger_monitor.rb(or whatever) and insert there given code:

file_path = File.expand_path(File.dirname(__FILE__))
# Load PassengerMonitor from '/lib/passenger_monitor.rb'
require File.join(file_path, '..', 'lib', 'passenger_monitor')

# Set logger to log into Rails project /log directory and start monitoring
  :log_file => File.join(file_path, '..', 'log', 'passenger_monitor.log')

There is one more thing that we need to do. We need to set it up in cron, so it will execute every minute. To do so we type crontab -e and insert following line in our crontab:

* * * * * env -i /usr/local/bin/ruby /rails/app/script/passenger_monitor.rb

Of course remember to replace /rails/app/ path with path to your application.

Checking if monitoring is working

How to check if monitoring is working? Go to you app root directory and type:

cat log/passenger_monitor.log

You should see something like this:

I, [TIMESTAMP]  INFO -- : Finished checking for bloated Passenger workers
I, [TIMESTAMP]  INFO -- : Checking for bloated Passenger workers
I, [TIMESTAMP]  INFO -- : Finished checking for bloated Passenger workers
I, [TIMESTAMP]  INFO -- : Checking for bloated Passenger workers
I, [TIMESTAMP]  INFO -- : Finished checking for bloated Passenger workers
I, [TIMESTAMP]  INFO -- : Checking for bloated Passenger workers
I, [TIMESTAMP]  INFO -- : Finished checking for bloated Passenger workers
I, [TIMESTAMP]  INFO -- : Checking for bloated Passenger workers
I, [TIMESTAMP]  INFO -- : Finished checking for bloated Passenger workers
I, [TIMESTAMP]  INFO -- : Checking for bloated Passenger workers
I, [TIMESTAMP]  INFO -- : Finished checking for bloated Passenger workers

To see only kill attemps, type:

cat log/passenger_monitor.log | egrep 'ERROR|FATAL'


E, [TIMESTAMP] ERROR -- : Found bloated worker: 4162 - 151.8MB
E, [TIMESTAMP] ERROR -- : Trying to kill 4162 gracefully...
E, [TIMESTAMP] ERROR -- : Waiting for worker to shutdown...
E, [TIMESTAMP] ERROR -- : Found bloated worker: 24192 - 152.6MB
E, [TIMESTAMP] ERROR -- : Trying to kill 24192 gracefully...
E, [TIMESTAMP] ERROR -- : Waiting for worker to shutdown...
E, [TIMESTAMP] ERROR -- : Found bloated worker: 3425 - 150.3MB
E, [TIMESTAMP] ERROR -- : Trying to kill 3425 gracefully...
E, [TIMESTAMP] ERROR -- : Waiting for worker to shutdown...

Debian (lub Ubuntu) i SVN (Submin, WebSVN) – mini słowniczek i podstawy użytkowania

Zanim zajmiemy się stricte tym jak używać SVNa i narzędzi do niego, zapoznajmy się z kilkoma pojęciami które są kluczowe w pracy z systemami kontroli wersji:

  • Repozytorium (repository) – foldery i pliki znajdujące się na serwerze SVN. Repozytorium zawiera w sobie oprócz plików i katalogów, także historię zmian w tych danych. Dzięki temu możemy prześledzić każdą zmianę dokonaną w obrębie repozytorium.
  • Head – najnowsza wersja plików dostępnych w repozytorium (wersja aktualna).
  • Rewizja (revision) – dana “wersja” plików. Przy zatwierdzaniu zmian na serwerze, numer rewizj jest podnoszony o 1. Dzięki temu możemy przywrócić system do stanu np z rewizji numer 46. System przechowywania danych, ze względu na oszczędność miejsca, jest systemem przyrostowym. Oznacza to że zapamiętywane są tylko zmiany, nie zaś stan całego kodu.
  • Kopia robocza – nasza lokalna wersja kodów źródłowych. Możemy na niej dokonywać zmian, eksperymentować, bez ryzyka zniszczenia czy też uszkodzenia kodu. Zmiany które uznamy za poprawne wprowadzamy (commitujemy) do repozytorium.
  • Checkout – pobranie z repozytorium kodów w celu utworzenia swojej kopii roboczej.
  • Gałąź główna (trunk) – główna linia projektu. Bardzo często ta gałąź ma zawierać w sobie kod źródłowy który się kompiluje i przechodzi wszystkie napisane do niego testy.
  • Gałąź rozwojowa (branch) – gałąź “poboczna”. W niej mogą być przechowywane nieskończone części kodu czy też kod zakończony częściowo. Kiedy w gałęzi tej kod zostanie już przetestowany i działa, można scalić ją z gałęzią główną.
  • Switch – przeskok między gałęziami w kopii roboczej.
  • Update – aktualizacja swojej kopii roboczej, plikami z repozytorium.
  • Commit – przesłanie naszych lokalnych zmian do repozytorium.
  • Merge (scalanie) – złączenie różnych gałęzi projektu w jedną.
  • Kolizja – sytuacja w której dany plik był modyfikowany przez różne osoby i w czasie scalania SVN nie mógł zdecydować która z wersji pliku jest poprawna. Musimy wtedy sami zdecydować którą wersję pliku uznać za właściwą.
  • Lock (blokada) – aby uniknąć sytuacji w której kilku programistów pracuje nad tym samym fragmentem kodu, można dane pliki zablokować. Po zablokowaniu inne osoby które chciałyby pracować nad danym plikiem, dostaną informację że nad tym plikiem ktoś już pracuje. Nakładanie locków pozwala uniknąć konfliktów przy mergowaniu.

Mając już podstawową wiedzę teoretyczną, zapoznajmy się z podstawowymi poleceniami jakie możemy wydawać z konsoli. Nie będę ich zbyt szczegółowo omawiał, ponieważ omówię narzędzia graficzne które bardzo ułatwiają pracę z systemami wersjonowania.

Tworzenie repozytorium

Tworzenie repozytorium z wiersza poleceń, jest relatywnie proste. Mając narzędzia Submin i WebSVN, musimy pamiętać tylko o tym, żeby tworzyć repozytoria w miejscach w których oba narzędzia je znajdą. Samo tworzenie repozytorium wygląda tak:

svnadmin create [nazwa repozytorium] 

Tworzenie kopii roboczej

Utworzenie kopii roboczej, jest równoznaczne z pobraniem odpowiednich plików z serwera. Wykonamy to wpisując w wierszu poleceń następującą komendę:

svn checkout svn://aders_naszego_serwera/[nazwa repozytorium]/ [nazwa projektu] 

Warto zauważyć że po utworzeniu kopii roboczej, w każdym katalogu będziemy mieli ukryty katalog .svn. Często jest w tych katalogach dużo plików, dlatego metoda “przeciągnij i upuść” w wypadku np. uploadowania projektu przez FTP może trwać bardzo długo.

Aktualizacja kopii roboczej

Aby zaktualizować naszą kopię roboczą, będąc w jej katalogu głównym wykonujemy następującą komendę:

svn update

Commit zmian na serwer

Przesłanie swoich zmian do głównego repozytorium także jest bardzo proste:

# Komentarz w którym opisujemy zmiany
svn commit -m "Komentarz"

I to by było na tyle jeśli chodzi o “konsolowe” podstawy. W następnej części zapoznamy się z Subminem.


Copyright © 2017 Running with Ruby

Theme by Anders NorenUp ↑