DEV Community: Eazybright😊😊

How to Recover MySQL Data from a .ibd File

Eazybright😊😊 — Thu, 24 Jul 2025 06:57:40 +0000

On a fateful day, you logged into your computer preparing to start the day's work but alas upon opening your MySql work tools you couldn't login due to error:

Error 2003 (HY000): Can't connect to MySQL server on '127.0.0.1:3306' (61)

This error means that MySQL is installed but not running or listening on the port 3306. If you use HomeBrew, you would have ran the command brew services list to see what is going on.

I ran the command below to see if MySQL is listening on TCP but nothing showed up:

lsof -nP -iTCP:3306 | grep LISTEN

After several debugging with no fix, I concluded that MySQL was corrupted and a fresh installation was necessary. But how do I recover my data?

First and foremost, backup your .ibd file as you still have the grace to restore them as we proceed in this article.
.ibd files are per-table tablespace files which contains the actual data and indexes for a single InnoDB table. They are binary files which can not be read easily.

Step 1: Backup your data

For Homebrew-installed MySQL, the default data directory is:

/usr/local/var/mysql.     # For Intel chips

/opt/homebrew/var/mysql    # For Apple Silicon chips

There are different files in the data directory: ibdata1, ib_logfile0, mysql.ibd, your_database_name/.
Each database is a folder, e.g.:

/opt/homebrew/var/mysql/your_database_name/
/opt/homebrew/var/mysql/your_database_name/your_table_name.ibd

Run (add sudo if necessary):

cp -r /opt/homebrew/var/mysql/your_database_name /opt/homebrew/var/backup_mysql/your_database_name

You should see a new directory /opt/homebrew/var/backup_mysql with the copied data intact.

Step 2: Uninstall Mysql

Stop the service:

brew services stop mysql // or mysql@8.* if you are using a specific version

Uninstall:

brew uninstall mysql

Remove MySQL configuration data (ensure you've backed up before doing this):

rm -rf /opt/homebrew/var/mysql
rm -rf /opt/homebrew/etc/my.cnf
rm -rf /opt/homebrew/etc/my.cnf.d

Step 3: Install New Mysql

brew update
brew install mysql
brew link mysql --force # link the MySQL binary

Start MySQL as a background service:

brew services start mysql

Check the status to ensure it has started successfully:

brew services list

Name    Status    User    File
mysql   started   root    ~Library/LaunchAgents/homebrew.mxcl.mysql.plist

Step 4: Restore Data to MySQL

I found this awesome tool that parses mysql .ibd file to sql
ibd2sql.

Clone the repo into your device:

git clone https://github.com/ddcw/ibd2sql.git

cd ibd2sql

// open the code with your favorite editor

This tool requires python3 and supports mysql versions 5, 8 & 9.

If your database has large tables, I wrote a bash script to automate things without having to run the .ibd recovery command one after the other as it is per table basis.

At the root directory, create a new bash file restore_data.sh and paste the below code:

#!/bin/bash

set -e

DB_NAME="your_database_name"
MYSQL_USER="root"
MYSQL_PASSWORD= # if you've protected the new MySql installation with a password, you have to provide one
IBD_DIR=~/opt/homebrew/var/backup_mysql/your_database_name             # Folder where all .ibd backup files are located (refer to step 1 above)

mysql -u root -e "CREATE DATABASE IF NOT EXISTS $DB_NAME; SET FOREIGN_KEY_CHECKS=0;"

# Find all .ibd files in the provided directory
for IBD_FILE in "$IBD_DIR"/*.ibd; do
    TABLE_NAME=$(basename "$IBD_FILE" .ibd)

    echo "📦 Restoring table: $TABLE_NAME"
    SCHEMA_SQL_PATH=$TABLE_NAME."sql"

    # read .ibd file and create a sql file requivalent
    python3 main.py $IBD_DIR/$TABLE_NAME.ibd --sql --ddl > $SCHEMA_SQL_PATH

    echo "📄 Recreating table structures and data from: $SCHEMA_SQL_PATH"
    mysql -u $MYSQL_USER $DB_NAME < "$SCHEMA_SQL_PATH"
done

save the file and make it executable:

chmod +x restore_data.sh

Run:

./restore_data.sh

When the execution is complete, your database should be populated with tables and it's data. A copy of each table schema has been saved in the root directory as well e.g. your_table.sql

Conclusion

We've been able to recover MySQL data from a .ibd file with the right steps and tools. While recovering strategy is possible, it is a time-consuming process so do well to backup your database regularly.

Is PHP dead? No, it's evolving!

Eazybright😊😊 — Sat, 05 Apr 2025 11:36:58 +0000

Year after year, misconceptions about PHP being dead resurface, but the reality is that PHP continues to evolve. The relevance of any technology is directly tied to its global usage and the community's ongoing contributions to its improvement.

In the ever-evolving landscape of web development, programming languages rise and fade, but PHP has remained resilient. It continues to evolve, adapting to modern web standards. According to W3Techs, PHP powers 74.5% of all known server-side websites, including major platforms like WordPress, which alone runs 43% of all websites on the internet. This enduring dominance is a testament to PHP’s relevance and reliability.

Source:W3Tech

The Evolution of PHP

PHP versions have grown from version 4,5,7,8. Each version comes with its own performance improvements. You can also disprove the false claim that PHP is slow, the latest version of PHP has proven otherwise. Per reports from Kinstart.com, they ran a benchmark to evaluate how the latest version of PHP performs with various CMS and frameworks. PHP8.3 provided up to 52.20% performance boost to the tested CMSs and frameworks.

Source: Kinsta

Recent PHP versions have introduced features like:

Anonymous classes: It allows you to create class instances without formally defining a class name. They are useful for one-time or temporary object and can pass arguments through to their constructors, extend other classes, implement interfaces, and use traits just like a normal class can.

$obj = new class {
    public function sayHelloWorld() {
        return "Hello World!";
    }
};

echo $obj->sayHelloWorld();

Just-In-Time (JIT) compilation: This was introduced in PHP 8.0 and it is a hybrid model of interpreted and Ahead-of-Time compilation, whereby some or all of the code is compiled at run time. Primarily, PHP is an interpreted programming language that does not have a compilation step and the code are executed directly in the virtual machine. With this feature, PHP can boast about performance improvements by compiling full or partial part of the PHP application and execute it. JIT can be enabled by adjusting the INI configuration similar to the below code:

opcache.enable=1
opcache.enable_cli=1
opcache.jit_buffer_size=256M

For full list of configuration options, visit Opcache Configuration

Type declarations: In PHP7.4 and above, you can now define types for function arguments, return values, and class properties. Strictly typed code allows PHP to optimize performance at the Opcache and JIT (Just-In-Time) compilation levels, leading to better efficiency and execution speed.
Match expression: This was introduced in PHP 8.0 to provide a more concise and expressive way to handle multiple conditions while ensuring strict comparison (===) by default. Compared to the switch statement, the match expression enables more concise and efficient code.
Example of a switch statement:

$status = 'pending';
$message = '';

switch ($status) {
    case 'pending':
        $message = 'Your request is being processed.';
        break;
    case 'approved':
        $message = 'Your request has been approved.';
        break;
    case 'rejected':
        $message = 'Your request has been rejected.';
        break;
    default:
        $message = 'Unknown status.';
}

echo $message; // Output: Your request is being processed.

Example of a match expression:

$status = 'approved';

$message = match ($status) {
    'pending'  => 'Your request is being processed.',
    'approved' => 'Your request has been approved.',
    'rejected' => 'Your request has been rejected.',
    default     => 'Unknown status.',
};

echo $message; // Output: Your request has been approved.

Named arguments: In PHP 8.0, maintaining a long list of arguments in the correct order is no longer necessary with named arguments. And you can also skip multiple optional parameters with ease.

<?php
function paintCar($brand = "Mercedez", $color = "yellow")
{
    return "I am painting a $color $brand car.\n";
}

echo paintCar(color: "blue");
?>

In earlier versions of PHP, you had to specify all default arguments, even when modifying only the second parameter

...

echo paintCar("Mercedez", "blue");

Asynchronous programming: Natively, PHP now allows asynchronous approach with the use of Fibers. It lets you pause and resume functions or sections of a code without blocking your application. Fibers let you run concurrent PHP code unlike the traditional synchronous PHP code, where codes are run from top to bottom. ReactPHP is also an excellent library to write event-driven, asynchronous PHP code.

Cross-platform Application Development

Have you heard about NativePHP?
It’s a framework that enables developers to build native desktop applications using PHP. With support for Windows, macOS, and Linux, it leverages familiar web technologies—HTML, CSS, JavaScript, and PHP—to create cross-platform applications. NativePHP runs on PHP CLI and local servers to render HTML-based interfaces, making desktop app development seamless for PHP developers.

Conclusion

Without further ado, PHP remains a powerful tool for building applications while staying relevant with modern technologies. Frameworks like Wordpress, Laravel, Symfony, NativePHP, and ReactPHP have transformed PHP development, providing robust solutions for creating scalable, efficient, and modern applications.

Apache Vs Nginx: How to choose your Preferred Web Server

Eazybright😊😊 — Mon, 17 Mar 2025 08:35:25 +0000

According to Wikipedia, a web server is a computer software that accepts requests via HTTP/HTTPS (HyperText Transfer Protocol). These requests can be used to retrieve or modify resources on the server.
In simple terms, a web server is software that facilitates information retrieval over the internet, enabling users to access websites and online resources.

Nginx and Apache are two of the most widely used web servers in the world today. Choosing between them depends entirely on your use case, as both can help you build and scale a powerful, fast, and high-traffic web application.

Let’s compare them to determine which one best suit your needs. Shall we?

Apache

Apache, developed in early 1995, was designed to serve both static and dynamic content on the internet. As one of the earliest and most widely used HTTP web servers, it has remained a cornerstone of web server technology to this day.

Apache supports multiple scripting languages, including PHP, Python, Perl, and Java, making it highly versatile. Its modular architecture allows users to configure features based on specific requirements, providing flexibility and customization for different web environments.

Characteristics of Apache

Apache follows a process-driven architecture, where each connection request is handled by a separate thread or process. This architecture causes heavy resource consumption (high memory usage) but Apache resolved this problem using multi-processing modules (MPMs). In Apache 2.4, the available MPMs are mpm_worker, mpm_event, mpm_prefork.
Apache delivers static content using a file-based approach. It can also handle dynamic content by embedding a processor for the programming language of choice within its worker instances. The introduction of LAMP and XAMPP made it possible for Apache to efficiently process dynamic content natively.
Apache uses distributed configuration approach. Apache allows configuration on a per-directory basis using the .htaccess file. This enables flexible and granular control over server settings, making it easier to manage individual directories.
It is compatible with major operating systems, such as Windows, MacOS, Linux.

Nginx

Nginx, introduced in 2002, was developed as a solution to the concurrency challenges that websites face at scale. It utilizes an asynchronous, non-blocking, event-driven connection handling algorithm, making it lightweight and easy to set up.

If your website is expected to handle high traffic, Nginx is an excellent choice, as it efficiently manages multiple concurrent connections within a single process.
Nginx can function in various roles, including web server, mail server, and reverse proxy.

Characteristics of Nginx

Nginx has an asynchronous architecture, which makes it deliver static content faster than Apache.
Nginx uses URL-based approach to deliver content. Requests for static files are mapped to a location on the filesystem.
It uses a centralized configuration approach. That is, all configurations are stored in a single place which makes it more performant than Apache because Apache checks for the existence of .htacess in each directory level before proceeding with the server request.
NGINX is primarily optimized for Unix-like systems, such as Linux and macOS. While it does support Windows, its performance on that operating system is generally less efficient compared to Linux.

Differences Between Apache and Nginx

While Apache and Nginx share similarities, they differ significantly in architecture, performance, and use cases. Below is a breakdown of their key differences:

Architecture: Apache is process-driven and less efficient at handling high traffic due to thread-based processing while Nginx is asynchronous, event-driven. It is much efficient under high-traffic.
Resource Consumption: Apache consumes higher memory usage. Nginx is efficient in CPU & memory usage; it uses minimal resources.
Request Interpretation: Apaches uses file-based approach, with the help of .htaccess files for per-directory configuration. Nginx is URI-based, does not search for a file path on the server.
Static & Dynamic Content: Apache process dynamic contents natively. Nginx is highly efficient for serving static contents but requires external processor to serve dynamic content.
Platform Support: Apache is compatible with Windows, Linus, MacOS operating systems. Nginx is optimized for Linus and MacOS operating system.

Conclusion

When selecting a web server for your project, several factors should be considered. If you're managing a small to medium-sized website with moderate traffic or require per-directory configuration flexibility, Apache is the ideal choice. However, for high-traffic websites, Nginx is the better option, offering excellent performance and built-in load balancing capabilities.
The interesting part is that you don’t have to choose just one—you can use both Apache and Nginx together. In this setup, Nginx acts as a reverse proxy, efficiently serving static files, while Apache handles dynamic content.
Ultimately, the best choice depends on your specific use case.

Resources:
https://httpd.apache.org/

https://nginx.org/

How to Develop an Air Quality Monitoring App with Ruby on Rails

Eazybright😊😊 — Fri, 03 Jan 2025 17:13:31 +0000

Prerequisites:

Ruby
sqlite3
Rails Installer

Install the app

rails new air_quality_app

serve the application

cd air_quality_app

bin/rails server

visit your browser with this link http://127.0.0.1:3000, you should have a similar display as below

Create a controller

To create FeedsController and its index action, run the controller generator in the terminal.

bin/rails generate controller Feeds index

install the Waqi Ruby SDK

Add this line to your application's Gemfile:

gem 'waqi-ruby'

And then execute:

bundle

Or install it yourself as:

gem install waqi-ruby

You need a token to conveniently access the Air QUality Open Data Platform API. Visit https://aqicn.org/data-platform/token/ to get a token.

Open your terminal to save the token

EDITOR=vim rails credentials:edit

You can change the editor to your preferred choice like nano.

Add the following line and save the file.

air_quality_data_token: <insert-the-api-token-here>

You should be able to access the token using the code: Rails.application.credentials[:air_quality_data_token]

Add some styling to the view

Use tailwind css for the styling. A tailwind ruby gem is available at https://github.com/rails/tailwindcss-rails, you can check it out for more details.

install tailwindcss

bundle add tailwindcss-rails
rails tailwindcss:install

The above commands will create files and folders necessary to kickstart designing with tailwind: app/views/layouts/application.html.erb, app/assets/builds/, config/tailwind.config.js, app/assets/stylesheets/application.tailwind.css, Procfile.dev, bin/dev.

Additionally, you can install foreman gem to run Tailwind in "watch" mode concurrently. Style changes are automatically reflected in the generated CSS output.

To configure tailwind to be applied in all template files, you can edit config/tailwind.config.js file.

Now serve the application: bin/dev
This will run both the rail server and tailwind watch.

Adjust your application layout to use nice UI. Update the body section of app/views/layouts/application.html.erb file with the code below:

...
<body class="flex flex-col justify-between">

    <header class="bg-gray-500 text-white shadow-lg">
        <nav class="mx-auto flex max-w-7xl items-center justify-between gap-x-6 p-6 lg:px-8" aria-label="Global">
            <h1 class="font-bold md:text-2xl m-0">
                WAQI Essentials
            </h1>
                <div class="flex flex-1 items-center justify-end gap-x-6">
                <p class="text-white text-sm font-semibold leading-6">City Feed</p>
                <p class="text-white text-sm font-semibold leading-6">Search</p>
            </div>
        </nav>
    </header>

    <main>
        <div class="max-w-7xl mx-auto p-6 lg:px-8 prose">
            <%= yield %>
        </div>
    </main>
</body>
...

Edit app/views/feeds/index.html.erb to use the parent layout that has the tailwind file configured.

<div class="text-center">
    <h1 class="text-3xl font-bold">City Feed</h1>
    <p>Get real-time Air Quality index for a given station.</p>
</div>
<form>   
    <label for="default-search" class="mb-2 text-sm font-medium text-gray-900 sr-only dark:text-gray-300">Search</label>
    <div class="relative">
        <div class="flex absolute inset-y-0 left-0 items-center pl-3 pointer-events-none">
            <svg class="w-5 h-5 text-gray-500 dark:text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z"></path></svg>
        </div>
        <input type="search" id="default-search" class="block p-4 pl-10 w-full text-sm text-gray-900 bg-gray-50 rounded-lg border border-gray-300 focus:ring-blue-500 focus:border-blue-500 dark:bg-gray-700 dark:border-gray-600 dark:placeholder-gray-400 dark:text-white dark:focus:ring-blue-500 dark:focus:border-blue-500" placeholder="enter name of city..." required>
        <button type="submit" class="text-white absolute right-2.5 bottom-2.5 bg-blue-700 hover:bg-blue-800 focus:ring-4 focus:outline-none focus:ring-blue-300 font-medium rounded-lg text-sm px-4 py-2 dark:bg-blue-600 dark:hover:bg-blue-700 dark:focus:ring-blue-800">Search</button>
    </div>
</form>

You should have a result as below:

Let's interact with api by submitting a city name and get a result.
First, modify the form tag to conform to rails code standard!

...
<%= form_with url: "/feeds/index", method: :get do |form| %>   
    <%= form.label :city, "Search", class:"mb-2 text-sm font-medium text-gray-900 sr-only dark:text-gray-300" %>
    <div class="relative">
        <div class="flex absolute inset-y-0 left-0 items-center pl-3 pointer-events-none">
            <svg class="w-5 h-5 text-gray-500 dark:text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z"></path></svg>
        </div>

        <%= form.text_field :city, placeholder: "enter name of city...", autofocus: true, required: true, value: @city,
            class:"block p-4 pl-10 w-full text-sm text-gray-900 bg-gray-50 rounded-lg border border-gray-300 focus:ring-blue-500 focus:border-blue-500 dark:bg-gray-700 dark:border-gray-600 dark:placeholder-gray-400 dark:text-white dark:focus:ring-blue-500 dark:focus:border-blue-500"
        %>

        <%= form.submit "Search", class: "text-white absolute right-2.5 bottom-2.5 bg-blue-700 hover:bg-blue-800 focus:ring-4 focus:outline-none focus:ring-blue-300 font-medium rounded-lg text-sm px-4 py-2 dark:bg-blue-600 dark:hover:bg-blue-700 dark:focus:ring-blue-800" %>
    </div>
<% end %>

<div class="text-center">
    <p><%= @feeds %></p>
</div>

You should notice the form_url tag has the url '/feeds/index'. After submitting the form the request goes to the index action on feeds_controller.

Modify the controller to accept the request and connect to Air Quality API to get a result:

# app/controllers/feeds_controller.rb

require 'waqi'

class FeedsController < ApplicationController
    before_action :set_client

    def index
        @city = request.query_parameters['city']

        if !@city.blank?
            @feeds = @waqi_client.get_city_feed(@city)
        end
    end

    private 

    def set_client
        @waqi_client = Waqi::Client::new(api_key: Rails.application.credentials[:air_quality_data_token])
    end
end

The above code does the following:

Loads the https://github.com/waqi-dev-community/waqi-ruby-client at the top of the file.
A before_action ruby method initialize set_client method. This method allows us to use the library in the code.
Index method accepts the query parameter city to be used.

When you search for a city let's say new-york, you should get this result in your browser:

You can beautify your result and integrate a Google line chart to display daily forecast for Ozone and Particulate matter level:

Add a script tag to app/views/layouts/application.html.erb file

...

<script type="text/javascript" src="https://www.gstatic.com/charts/loader.js"></script>
    <script type="text/javascript">
        google.charts.load('current', {'packages':['line']});
        var forecast = document.getElementById('line_top_x').getAttribute('data-forecast')
        if(forecast.length) {
            google.charts.setOnLoadCallback(drawChart);
        }

        function drawChart() {
            var data = new google.visualization.DataTable();
            data.addColumn('string', 'Date');
            data.addColumn('number', 'Ozone (o3)');
            data.addColumn('number', 'Particulate Matter 10 (pm10)');
            data.addColumn('number', 'Particulate Matter 25 (pm25)');
            data.addRows(JSON.parse(forecast));

            var options = {
                width: 900,
                height: 500,
                axes: {
                    x: {
                        0: {side: 'top'}
                    }
                }
            };

            var chart = new google.charts.Line(document.getElementById('line_top_x'));

            chart.draw(data, google.charts.Line.convertOptions(options));
        }
    </script>
</body>
</html>

The script loads the chart library and the forecast data is inserted by getting the data attribute on the page app/views/feeds/index.html.erb:

var forecast = document.getElementById('line_top_x').getAttribute('data-forecast')

Insert this code snippet below into the city_feed views page:

<% if @isError %>
    <div class="m-4 p-2 text-red-500">
        <span>Error: <%= @response["data"] %></span>
    </div>
<% else %>

    <div class="text-center grid grid-flow-row-dense grid-cols-4 grid-rows-4">

        <p><span class="font-black">City: </span> <%= @city_info["name"] %></p>
        <p><span class="font-black">Latitude: </span><%= @city_info["geo"][0] %></p>
        <p><span class="font-black">Longitude: </span><%= @city_info["geo"][1] %></p>

        <% if !@iaqi.blank? %>
            <% @iaqi.each do |iaqi|  %>
                <% extra = determineLabel(iaqi["name"]).to_h %>
                <p><span class="font-black"><%= extra["label"] %>: </span><%= iaqi["value"] %> <%= extra["unit"] %></p>
            <% end %>
        <% end %>
    </div>

    <div class="text-center">
        <h3> Daily forecast for Ozone, Particulate Matter 10 and 25</h3>
        <div id="line_top_x" style="margin-right: auto;margin-left: auto;display: table;" data-forecast="<%= @daily_forecast %>"></div>
    </div>

<% end %>

The code above handles the error if there's any and also display the city, latitude, longitude, and other air quality information for a particular station.

This line of code <% extra = determineLabel(iaqi["name"]).to_h %> is used to format the data with readable texts and provide more information to the user. You can update the app/helpers/application_helper.rb with the code below. This is a helper class.

module ApplicationHelper
    def determineLabel(name)
        case name
        when "co"
            { "label" => "Carbon monoxide", "unit" => "ppm" }
        when "no2"
            { "label" => "Nitrogen dioxide", "unit" => "ppb" }
        when "pm10"
            { "label" => "PM10", "unit" => "µg/m³" }
        when "pm25"
            { "label" => "PM25", "unit" => "µg/m³" }
        when "o3"
            { "label" => "Ozone", "unit" => "ppb" }
        when "w"
            { "label" => "Wind Speed", "unit" => "m/s" }
        when "t"
            { "label" => "Temperature", "unit" => "°C" }
        when "p"
            { "label" => "Air pressure", "unit" => "mb" }
        when "so2"
            { "label" => "Sulfur dioxide", "unit" => "ppb" }
        when "h"
            { "label" => "Humidity", "unit" => "%"} 
        when "dew"
            { "label" => "Dew", "unit" => "°C"}
        end
    end
end

Update the index method on FeedsController file:

def index
        @city = request.query_parameters['city']
        if !@city.blank?
            response = @waqi_client.get_city_feed(@city)

            if response["status"] == "ok"
                @response = response["data"]
                @city_info = response["data"]["city"]

                @iaqi = response["data"]["iaqi"].map do |key, value|
                      { "name" => key.to_s, "value" => value["v"] } 
                end

                @forecast = response["data"]["forecast"]["daily"]

                @daily_forecast = format_forecast_data(@forecast)

            elsif response["status"] == "error"
                @isError = true
                @response = response
            end
        end
    end

private 

... 

def format_forecast_data(air_quality_data)
        # Extract days from "o3", "pm10", and "pm25" arrays
        o3_days = air_quality_data["o3"].map { |data| data["day"] } || []
        pm10_days = air_quality_data["pm10"].map { |data| data["day"] } || []
        pm25_days = air_quality_data["pm25"].map { |data| data["day"] } || []

        # Find intersection of the three arrays
        identical_days = o3_days & pm10_days & pm25_days
        formatted_parameter_data = []

          # Extract required values and push into new array
        identical_days.each do |date|
            o3_index = air_quality_data["o3"].find_index { |entry| entry["day"] == date }
            pm10_index = air_quality_data["pm10"].find_index { |entry| entry["day"] == date }
            pm25_index = air_quality_data["pm25"].find_index { |entry| entry["day"] == date }

            formatted_parameter_data << [date, air_quality_data["o3"][o3_index]["avg"], air_quality_data["pm10"][pm10_index]["avg"], air_quality_data["pm25"][pm25_index]["avg"]]
        end
        formatted_parameter_data
    end

You can explore more functionality with the ruby sdk such as Lat/Lng based Geolocalized feed, IP based Geolocalized feed, etc.

The complete source code can be found on github