Shadab Ahmed

Fan Mod for Meanwell Power Supply

Fri, 02 May 2025 00:00:00 +0000

Parts Required
Modding Steps
Final Result

Working in robotics often means dealing with reliable yet noisy Meanwell power supplies. Unfortunately, the tiny 40mm fans inside the specific models I work with, are incredibly loud, significantly affecting comfort and actually worsened my tinnitus. In an effort to reclaim some sanity, I embarked on a modding adventure to silence my Meanwell PSU. Here’s a straightforward guide on how you can do the same. The specific model I worked with is RSP-2000

⚠️ Caution:
Meanwell power supplies can retain charge even after power-off. Ensure the unit is unplugged and powered off for at least a few hours before opening it up.

Parts Required

Fan Cable Adapters (2-pack, 4-pin):
- Allows connection of larger fans to Meanwell’s small fan headers.
- Note: You’ll need to re-pin these cables (details below).
2 x 120mm CPU Cooling Fans:
- Any standard brand works, but for silent operation, I highly recommend:
  - Noctua NF-A12x15 PWM chromax (ultra-quiet & reliable).
- RGB fans are also an option if you want aesthetics, provided you have a motherboard or RGB controller to power the lights.
Mesh Filters (ATX case dust filters):
- Protects internal components from dust while maintaining airflow.

Modding Steps

1. Open the Meanwell PSU Case

Unscrew and remove the top cover.
Remove the two noisy 40mm fans, carefully scraping off any hot glue.

You’ll see two exposed 4-pin connectors:

2. Prepare the Fan Adapter Cables

The default adapter pinout will damage your fans if connected directly. You need to pry out the individual wires and re-pin the adapters following this schematic:

Larger End (for the new fans):

Smaller End (connects to Meanwell PSU):

3. Connect and Prepare the Fans

Zip-tie the two 120mm fans together for easy mounting:

4. Connect Fans to Meanwell PSU

Plug fan connectors into the larger ends of adapter cables.
Connect smaller adapter ends to Meanwell’s PCB connectors.
Route cables neatly through bottom openings for tidy management:

I also used aluminum metal tape (used on dryer vents) to secure loose cables

5. Cover PSU with Mesh Filter

Cut ATX mesh filter to match Meanwell PSU dimensions.
Cover PSU top opening to allow airflow yet protect from dust:

6. Mount Fans onto the PSU

Position fans on top of the PSU, aligning carefully.
Secure with screws through fan corners. You might need to drill small holes in fan frames for alignment:

Optionally, cover side openings and cable gaps using aluminum tape for better airflow management.

Final Result

Enjoy your newly quiet, cool-running Meanwell power supply. My PSU is now effectively unnoticeable and temperatures are good to touch even at load. Here’s my completed mod in it’s full RGB glory powering both the motherboard (via pico-itx) and also the robot arm:

A Smarter TV Mount with Arduino

Tue, 28 Jun 2022 00:00:00 +0000

TLDR;

Used an Arduino Nano to make a TV Mount smarter. Jump to the Final Setup section for a demo video.

Intro

Since I’m on a break in-between jobs, I thought I’d revisit my old blog and post about something interesting I’ve done during the time. I’ve been wanting to place our TV on the fireplace mantel in our family room. However, it makes the TV too high to watch. To fix this, I installed a motorized above-fireplace TV mount to lower the TV down while watching. This Monoprice TV Mount seemed perfect for it:

It does handle the weight pretty well. However, a few major issues:

The remote is horrible. It picks up IR signals from the TV remote and moves on things like volume up/down/mute etc. Super annoying!
It has a powerful motor, but no sensor to stop if something is obstructing. It literally can crush anything which comes in its way.
If you press the up button for too long, the motor keeps hammering as it’s stuck at the top-most position and doesn’t know it should stop.
At the top-most position, you can still swivel the TV right/left, possibly hitting the wall. Guaranteed to damage the TV or the wall behind it.

I decided to make it better with features like:

RF remote instead of IR, so it isn’t affected by the TV remote or any other IR source
Detect if the TV is too close to the wall and prevent any further moving up to prevent damage to the mount or the TV
Detect motor stalls or obstructions by measuring motor current and stop the motors in such fault conditions
Move the mount to the rest position(top-most) automatically, when the TV is turned OFF
Similarly, move the mount to the viewing position(bottom-most) automatically, when the TV is turned ON

Components

Here’s a block diagram of the whole system:

The two time-of-flight(TOF) distance sensors are VL53L0x sensors I bought from Amazon. These are pretty accurate from 20mm to 2000mm. These are placed behind the TV on the opposite ends to detect the distance from the wall, as well as the swivel angle.

The Circuit

The circuit is just soldered on two separate prototype PCBs, layered one over another. The top part contains the Arduino and connectors for the sensors. Also has a USB connector for the cable coming from the TV for TV On/Off detection. The bottom part contains the two H-bridges for the two motors in the mount(up/down and swivel). There’s a DC/DC converter as well, for running the Arduino from the 24V power supply.

Fits nearly perfectly in this enclosure built for Raspberry PI:

The Code

Github Repo

The code is written in C++ using the Arduino framework. I initially started coding in Arduino IDE but as the code got bigger, switched over to the Jetbrains CLion using the Platform IO framework. I must say that CLion is so much better to write code in!

The main part of the code is a state machine, that manages the various states and transitions based on the inputs from the remote/sensors.

As a side challenge, I also ported the code to an almost pin-compatible Arduino Nano RP2040, which is based on the Raspberry Pi Pico microcontroller.

Final Setup

Right now, I crammed the circuit, power supply etc in a cable box. I do plan to make it neater. Videos(5x speed) of the whole setup with TV On/Off function:

Conclusion

This has been a fun little project to do, and pretty useful as well. I last coded on a microcontroller (AVR Atmega series) in 2008, and it was all on custom-manufactured circuit boards. Comparing that to now, here’s what I observed:

There are many microcontrollers available today with a host of connectivity options like LoRa, Wifi, Bluetooth etc.
You can buy fully assembled breadboard-ready microcontroller boards for just a few dollars
The diversity in the microcontroller choice is also supplemented by a good set of frameworks like Arduino, Platform IO etc. Not too hard to write portable code without a lot of changes like I did with Arduino Nano RP2040
You can virtually find any sensor on Amazon, Sparkfun, AdaFruit or many other sites.

Overall so much easier to do your hobby projects today. I too hope to pick up a few other cool projects as well. Will keep you posted. Cheers !!!!ß

Single Value Tree

Thu, 30 Nov 2017 00:00:00 +0000

Another popular tree question:

Given a binary tree, count the number of unival subtrees(all nodes having the same value). For e.g. in the tree below, all the subtrees enclosed in ellipses are unival trees.

Above tree was generated using the graphviz library. The result for the tree above would be 6. There is a C++ implementation around. The time complexity is O(n).

The ruby implementation looks a lot simpler owing to the fact that it can return multiple values. Here it is:

# let's quickly create a tree
class Node < Struct.new(:val, :left, :right); end
root = Node.new(5)
root.left = Node.new(5)
root.left.left = Node.new(5)
root.left.right = Node.new(5)
root.right = Node.new(5)
root.right.right = Node.new(5)

# this function returns true if:
# a. child is nil
# b. child is not nil and it has same value as parent plus it's subtree is a unival until the child
def is_unival?(node, child, is_child_unival)
  is_child_unival && (child.nil? || node.val == child.val)
end

def unival_subtrees(node)
  # if node is nil, the subtree count is obviously 0 and it is unival
  return [true, 0] if node.nil?
  is_left_unival, left_count = unival_subtrees(node.left)
  is_right_unival, right_count = unival_subtrees(node.right)
  # check is left and right subtrees are unival and the current node and children have same values
  if is_unival?(node, node.left, is_left_unival) &&
     is_unival?(node, node.right, is_right_unival)
    # Add one more subtree which includes current node to the total count
    [true, left_count + right_count + 1]
  else
    [false, left_count + right_count]
  end
end

# test by calling the unival_subtrees method
unival_subtrees(root)
=> [true, 6]

This was a fun question to solve. Let me know your thoughts in comments. Cheers!!!

BST Inorder Sucessor

Wed, 18 Oct 2017 00:00:00 +0000

Getting back to blogging after a long time. Whatever be the reasons, just want to share a quick insight I had yesterday.

Finding an in-order successor to a BST node is a pretty popular problem. While trying to think of it, I realized I could create a more elegant solution than what I could find online. I don’t know if similar solutions exist but here is a ruby implementation anyway (explanation within the comments):

# let's quickly create a tree
class Node < Struct.new(:val, :left, :right); end
root = Node.new(4)
root.left = Node.new(2)
root.left.left = Node.new(1)
root.left.right = Node.new(3)
root.right = Node.new(6)
root.right.left = Node.new(5)
root.right.right = Node.new(7)

# finding min in a tree, simple to do
def find_min(node)
  return if node.nil?
  if node.left.nil?
    node
  else
    find_min(node.left)
  end
end

def find_successor(node, val, possible_successor = nil)
  return if node.nil?
  if val == node.val && node.right
  # if found and node has right, then successor is min in right
    find_min(node.right)
  elsif val == node.val
  # if found and node has no right, then it is one of the ancestors
    possible_successor
  elsif val < node.val
  # if the value is on the left subtree,
  # then current node is possible successor.
  # Pass it as possible_successor
    find_successor(node.left, val, node)
  else
  # if the value is on the right subtree,
  # then current node can't be possible successor.
  # Pass along ancestor which could be successor
    find_successor(node.right, val, possible_successor)
  end
end

# test by calling find_successor method
find_successor(root, 3).val
=> 4

I’ll be more frequent with new posts now. I promise :)

Mysterious Killer of my Processes

Thu, 21 May 2015 00:00:00 +0000

Recently I had deployed my node app on one of the overloaded linux servers, I was using. It uses cluster node library, which also sends me notification if any child process is killed and then it respawns the child.

So ever since deployment, everyday around lunch, I would get a hella-lot of emails about the child processes being killed. The weird thing was that every one of the child process were receiving SIGKILL, thus someone was killing them. During the carnage which would last for around 2-3 hours, even processes such as npm install would be killed, just as mercilessly.

Shutting down a few processes did help. It slowed down the killing, but did not stop it completely. Only passing of time would stop it, so by late evening till next day lunch, the carnage was again silent.

So next day, I figured out what other thing was happening at the same time. It turns out that another team was uploading a huge data which also involved lots of processing and thus system was becoming OOM (Out of Memory) and the OOM Killer was killing my processes. Looking at the mem stats:

free -m
             total       used       free     shared    buffers     cached
Mem:          2008       1995         13          0          0         23
-/+ buffers/cache:       1971         36
Swap:         1535       1535          0

This server was super-contrained for memory and the kernel OOM Killer kicked in to reclaim memory. Obviously not ideal amount of RAM and even worse SWAP space but this was a sandbox server, so a bit of unsettleness dint matter so much. Looking at more logs for oom killer:

grep -i 'kill' /var/log/messages | awk -F 'kernel:' '{print $2}'
 [1776235.313736] PassengerHel/ei invoked oom-killer: gfp_mask=0x201da, order=0, oom_adj=0
 [1776235.313791]  [<ffffffff810b8dec>] oom_kill_process+0xcc/0x2f0
 [1776235.322903] Out of memory: kill process 12050 (ruby) score 113591 or a child
 [1776235.322906] Killed process 12050 (ruby)
 [1776766.287970] python invoked oom-killer: gfp_mask=0x201da, order=0, oom_adj=0
 [1776766.288033]  [<ffffffff810b8dec>] oom_kill_process+0xcc/0x2f0
 [1776766.298348] Out of memory: kill process 12121 (ruby) score 112262 or a child
 [1776766.298350] Killed process 12121 (ruby)
 [1776766.304348] python invoked oom-killer: gfp_mask=0x201da, order=0, oom_adj=0
 [1776766.304389]  [<ffffffff810b8dec>] oom_kill_process+0xcc/0x2f0
 [1776766.313545] Out of memory: kill process 8259 (python) score 85423 or a child
 [1776766.313548] Killed process 8259 (python)
 ...truncated

As sou can see, OOM Killer killed a number of processes. The best way to resolve this OOM Killing, is to add more RAM and SWAP space. You can see more helpful reference for the OOM Killer here:

oom-killer

will-linux-start-killing-my-processes-without-asking-me-if-memory-gets-short

where-can-i-see-a-list-of-kernel-killed-processes

Integrating Slack With Github Enterprise

Fri, 06 Mar 2015 00:00:00 +0000

If you are using Slack(Yes it’s awesome) and Github Enterprise(Awesome too), then you might have played around with the integration of both the tools.

The Slack documentation helps a bit but to have a complete integration with issues, issues comments etc, you’ll have to jump through some hoops. So let me put it all below.

Adding Webhook in Github Enterprise for your Slack group/channel

First step is to obviously add a hook in your company’s Github Enterprise repo for Slack. Skip to next section if you’ve already addded the Github Webhook.

Click on the Add Service Integration menu link for your group
Select your Slack group or channel where you want the Github notifications:
Now click on the switch to unauthed mode
Copy the Webhook URL you see on the next screen. Now goto the Settings > Hooks page of your repo in Github Enterprise. Add a Webhook and paste the Webhook URL there.

After adding the Webhook you should receive notifications when anyone pushes commits to your repo.

Updating Webhook in Github Enterprise to support more notifications

Now you may have noticed that even after adding a Webhook, you can only see notifications for new commits. The integration is still missing notifications for events such a new issue or issue comment etc.

The reason is that Webhook only publishes commit events by default. You can change this behaviour by altering the hook via Github Webhook API

Assuming your Github Enterprise link as http://githuben.mycompany.com/, your organization as myorg and repo as myrepo

1 . Find your hook url (containing the hook id) by retrieving a list all the hooks for a repo:

curl --user "<User>:<Password>" http://githuben.mycompany.com/api/v3/repos/myorg/myrepo/hooks

You should see a big JSON output. All you need is the url of the hook matching your Slack Webhook integration url.

 [
    {
      "url": "http://githuben.mycompany.com/api/v3/repos/myorg/myrepo/hooks/1121",
      "test_url": "http://githuben.mycompany.com/api/v3/repos/myorg/myrepo/hooks/1121/test",
      "id": 1121,
      "name": "web",
      "active": true,
      "events": [
        "push"
      ],
      ....
      "config": {
            "url": "https://hooks.slack.com/services/SOMEHASH/SOMEHASH/SOMEHASHBUTLONGER",
            "content_type": "form",
            "insecure_ssl": "1"
          },
      ....

You can see in the JSON aboce, that events in the hook is only push. The url for our Slack hook is - http://githuben.mycompany.com/api/v3/repos/myorg/myrepo/hooks/1121

2 . Now add all the extra notifications to the events for the Webhook using the hook url from above:

curl -X PATCH --user "<User>:<Password>"  -H "Content-Type: application/json"
http://githuben.mycompany.com/api/v3/repos/myorg/myrepo/hooks/1121
-d '{"add_events": ["commit_comment", "create", "issue_comment", "issues", "pull_request_review_comment"]}'

That’s all. You should now be able to receive notifications for all these events apart from push. You can call the Get Hooks api again to confirm.

Inside Git Guts

Tue, 18 Mar 2014 00:00:00 +0000

TLDR; Git is greatly extensible. I made many custom commands to create an interesting talk on “The Insides of Git”. Skip the text and just watch the video for details.

Back in June last year in the cool city of Pune at the RubyConf India 2013, I gave a talk on Git. It was aptly titled Inside Git Guts with Ruby.

The idea was to explore what happens inside the .git folder when you do git operations like commit, push, merge etc. The talk was far more about git than ruby. Infact, the part with Ruby in the title was added just to ensure a better chance of my proposal getting selected for RubyConf. Although, all of the tools I showed in the talk were written in Ruby, the actual ruby code shown was just about 4 lines.

Now, here’s the actual talk:

The talk was greatly inspired by the movie Inception. Infact I even had a command git inception which gave the following output(truncated):

$ git inception                                           
                        .git
                     .git
                  .git
               .git
            .git
         .git
      .git
   .git <--- 2nd Level Gitception
.git

The Inception bit was actually the most interesting part of the talk. There were other super cool commands like - git music, git autocommit, git server, git fireworks, git quote, git about and more

Lots of folks have asked me to share the code and the instructions, so here’s the code. To get all the tools on your system:

gem install git_guts

Bang Bang !!

Fri, 16 Aug 2013 00:00:00 +0000

The more you learn about the linux shell, the more you love it. Reason I am saying this because I recently saw this:

This made me immediately google it and I found an excellent reference here. This is a quick summary of the source:

$ !!                     # Repeat last command
$ !x                     # Repeat last command that started with x
$ !?x                    # Repeat last command that has the substring x
$ !10                    # Repeat 10th command in the history file
$ !-10                   # Repeat 10th from last command in the history file
$ !!*                    # Fetch parameters from last command
$ !!^                    # Fetch first parameter from last command
$ !!$                    # Fetch last parameter from last command
$ !!3                    # Fetch third parameter from last command
$ !!:s/foo/bar/          # Repeat last command substituting foo for bar

If you append :p to any of the above commands then it will only print the command than running it

Infinite Bang Bang

Now what if the last command also contains a !!. Would it become recursive ? Let’s see:

# : is noop operator. This command sets up our base. 
# Note that the !! inside single quote doesn't expand to the previous command
$ : '!!'
  
# Let's start our recursive operation in here. This is the first sequence in the chain
# Only the !! inside double quotes expands to the previous command - : '!!'
$ : "!!" '!!'

: ": '!!'" '!!'

# Pressing up arrow, we have a second sequence
# Once again, only !! inside double quotes expands and !! appears 3 times after expansion
$ : ": '!!'" '!!'

: ": ': ": '!!'" '!!''" '!!'

# Now, third sequence - !! appears 5 times
$ : ": ': ": '!!'" '!!''" '!!'

: ": ': ": '!!'" ': ": ': ": '!!'" '!!''" '!!'''" '!!'

# Fourth Sequence - !! appears 17 times
$ : ": ': ": '!!'" ': ": ': ": '!!'" '!!''" '!!'''" '!!'

: ": ': ": '!!'" ': ": ': ": ': ": ': ": '!!'" ': ": ': ": '!!'" '!!''" '!!'''" '!!''" ': ": ': ": '!!'" ': ": ': ": '!!'" '!!''" '!!'''" '!!'''" ': ": ': ": '!!'" ': ": ': ": '!!'" '!!''" '!!'''" '!!''''" '!!'

# Fifth
$ : ": ': ": '!!'" ': ": ': ": ': ": ': ": '!!'" ': ": ': ": '!!'" '!!''" '!!'''" '!!''" ': ": ': ": '!!'" ': ": ': ": '!!'" '!!''" '!!'''" '!!'''" ': ": ': ": '!!'" ': ": ': ": '!!'" '!!''" '!!'''" '!!''''" '!!'

: ": ': ": '!!'" ': ": ': ": ': ": ': ": '!!'" ': ": ': ": ': ": ': ": '!!'" ': ": ': ": ': ": '
... # !! appears 161 times

In the sixth sequence !! appears 15681 times and in the seventh, more than 150 million times. Do not even try to run it for the 7th iteration unless you want to end up with a 2GB history file and your shell stuck for hours at 100% CPU.

The 8th sequence has more than 16 Quadrillion bang bangs

Now, I haven’t been able to figure out the exact equation yet for the number of !! in nth sequence, but this is what happens:

Any !! not surrounded by any quotes is expanded to the previous command
!! surrounded only by single quotes '!!' do not expand
!! surrounded by double quotes at the outermost level are expanded, even if that bang bang is nested inside single quotes. For e.g. " '!!' "

The approximate equation is like this:

f(n) ~ f(n-1)*f(n-1)/2 + f(n-1)/2

Let me know if you can figure out the exact equation. The above commands have been tested on sh and bash.

Update: Thanks to Volker, we have code to calculate the exact number of bang bangs in nth sequence, here, which works till the 7th sequence.

Volker has even submitted the Bang Bang Numbers at OEIS and the sequence has been accepted. View it over here

Update2: Robin Houston wrote an analysis of these numbers on his blog. He also wrote this code for generating the numbers in the Bang Bang Numbers series:

# /usr/bin/env python
p, q = 2, 4
for i in range(4, 16):
  print "%d: %d" % (i, 4*p + 2*q + 1)
  p,q = 3*p*p + 2*p + p*q, 2*q + 2*p*p + 2*p*q 

Split Tunneling on VPN via Routing Table

Sun, 11 Aug 2013 00:00:00 +0000

Split Tunneling

Whenever I connect to VPN on my mac, my default route is modified to this:

$ netstat -nr
Routing tables

Internet:
Destination        Gateway            Flags        Refs      Use   Netif Expire
default            utun1              UCS            34        0   utun1 
default            192.168.2.1        UGScI           0        0     en0

What this does is, route all my traffic, even the one which is outside of VPN network routed through the VPN interface utun1. The second default route via 192.168.1.1 is not even used. This is unnecessary and sometimes counterproductive as the VPN network takes extra load on bandwidth/resources for the IPs outside of its network and even bans sites which do not require banning.

You can easily change your routing table to circumvent this using the script below. This way you access public IPs directly and private IPs over VPN. This concept is called Split Tunneling

Modifying Routing Table

Now to modify routing table for split tunneling, all you need to do is to find out the subnet of the IPs in your VPN you need access to. Let’t take for example, if the subnets of my VPN private space are 10.109.0.0 and 10.110.0.0 (Any IPs starting with 10.109 and 10.110):

#! /usr/bin/env bash
if (( EUID != 0 )); then
  echo "Please, run this command with sudo" 1>&2
  exit 1
fi
WIRELESS_INTERFACE=en0
TUNNEL_INTERFACE=utun0
GATEWAY=$(netstat -nrf inet | grep default | grep $WIRELESS_INTERFACE | awk '{print $2}')

echo "Resetting routes with gateway => $GATEWAY"
echo
route -n delete default -ifscope $WIRELESS_INTERFACE
route -n delete -net default -interface $TUNNEL_INTERFACE
route -n add -net default $GATEWAY
for subnet in  10.109 10.110
do
  route -n add -net $subnet -interface $TUNNEL_INTERFACE
done

Just save the script as /usr/bin/vpn and whenever you connect to vpn, just run sudo vpn. This is what the script does:

Finds wireless router IP (en0)
Remove the default routes set by VPN
Set the IP found for en0 as the default gateway
Add the specific routes for your VPN subnet

If you are connecting over wired network, just change the en0 in script to en1. Don’t change your VPN DNS to make sure you can resolve private domains on the VPN.

Looking at the routing table again after running the script:

$ netstat -nr
Routing tables

Internet:
Destination        Gateway            Flags        Refs      Use   Netif Expire
default            192.168.2.1        UGSc            1        0     en0
...
10.109                 utun1              USc            0        0   utun1
10.110                 utun1              USc            0        0   utun1

As you can see now, our default gate is back to wifi router IP - 192.168.1.1 on en0 and there are some routes for the subnets inside the VPN.

You can test the route as well with a route command. Route for any IP outside of your VPN:

$ route get google.com                                            
route to: lga15s29-in-f5.1e100.net
destination: default
   mask: default
   gateway: 192.168.1.1
   interface: en0
   flags: <UP,GATEWAY,DONE,STATIC,PRCLONING>
   recvpipe  sendpipe  ssthresh  rtt,msec    rttvar  hopcount      mtu     expire
            0         0         0         0         0         0      1500         0

Route for IP inside your VPN:

$ route get 10.109.10.135
route to: 10.109.10.135
destination: 156.107.0.0
   mask: 255.255.0.0
   interface: utun0
   flags: <UP,GATEWAY,DONE,STATIC,PRCLONING>
   recvpipe  sendpipe  ssthresh  rtt,msec    rttvar  hopcount      mtu     expire
            0         0         0         0         0         0      1280         0

To reset the routing table back, just disconnect from the VPN. Same script can be used on Linux with some modifications.

Logstasher - For awesome Rails logging

Tue, 30 Apr 2013 00:00:00 +0000

Rails Logs

Rails logging is a mess, atleast the default one. I’ve even seen some gems, spewing garbage into the logfile with no predefined format. Good thing is that you can easily fix/customize it. Infact, you can customize it so much, that you can have this:

What’s there in these supposedly awesome logs ?

Superfast search backend
UI is much much cooler than, what the single screenshot shows
You can add custom fields such as username and custom rails instrumentations
Consolidation of logs across multiple servers
Email notifications on events such as exceptions

How it’s done ?

The slick UI with superfast search is made possible with Rails Logs using:

Logstasher Gem - A rails gem I wrote. It makes rails, generate logstash compatible logs with minimal overhead
Logstash - An open source log collector
Kibana - A ruby/rack application for visualization and searching the logstash index

Logstasher Gem

I have already written much about it on the README at Github. Please check it out to know the usage/installation

Logstash

Now this is the core of the logging system. It collects and stores the logs. It has a very clean seperation of concerns, basically:

Inputs - The source for logs. There are tons of options for input sources. We’ll be using file input for local logs and lumberjack for remote logs.
Filters - These are tranformations you would like to apply on the input log. Used for sanitizing and appending any extra information. Since logstasher already sends sanitized logs, we’ll not need any filters, thus saving on some processing.
Ouputs - Again we have many options for outputs. We will use the email and elastic-search output.

See the full list of input, filter and output options here

Setting up logstash

You can compile the jar from source code or download it. My preference is to compile, since it is newer (more fixes). Copy the jar file to /opt/logstash/logstash.jar
Set it up as a service - Ubuntu and SUSE SLES init.d scripts
Setup your config file - See sample config file. Copy it to /etc/logstash/logstash.conf. The email output functionality is not perfect yet. I am waiting still for this pull request to be merged.

Once your logstash is setup, you now need to configure input source. If the rails app is on the same machine, you can skip the lumberjack section.

For output we’re using the embedded elastic-search, so no need for any extra setups.

Lumberjack

If your app resides on a remote server, or there are multiple app servers, you need to transport the logs to logstash. Lumberjack is a very fast and small utility to do the same with minimal memory usage. It also encrypts the logs, so super secure as well. It will just monitor your logfile for changes and on any updates, sends the new logs to logstash.

Setting up Lumberjack

I found compiling lumberjack to be a bit of pain on SUSE(Yes, unfortunately I have to use SUSE). You can have a go yourself by grabbing it from source. You will need to install Go Language to compile it. Luckily I found rpm and deb packages here. Install the deb by dpkg -i debfilename or rpm by rpm -i rpmfilename
Set it up as a service - init.d script
Set up the config file - sample config. Create the config file at /etc/default/lumberjack

It is a good idea to restart lumberjack when you deploy or rotate logs.

There is a new protocol for lumberjack v2. I will play with it and update the documentation on that.

Key and SSL Certificate for lumberjack

You’ll notice that key and certificate files are required by logstash and lumberjack. These are required just to encrypt the log shipping. All the commands I used to generate them are consolidated here

Kibana

This is the easiest part. Just see here

Once you have everything setup, you should be able to see logs in the Kibana UI. Play around to see the powerful search feature. You can also write your custom queries for .e.g. to get all requests from an IP which raised an exception just put this query in the search field - ` @fields.ip:”157.191.96.84” AND @tags:”exception”`

Inspirations

https://github.com/roidrage/lograge
[http://www.vmdoh.com/blog/centralizing-logs-lumberjack-logstash-and-elasticsearch] (http://www.vmdoh.com/blog/centralizing-logs-lumberjack-logstash-and-elasticsearch)
Loggly and Logentries