Multi-tenancy

Advantages

• Shared infrastructure lead to lower costs by sharing same power resources and software across its clients.
• In single-tenant applications, you have to manage different sets for each client while in multitenant applications you have to monitor and provide administration for a single platform only.
• Entire system becomes more scalable
• Upgrading the software version and installation becomes easier for multitenant applications.
• Easier to add new clients.
• Configuration can be changed without touching codebase.
• Easy maintenance

Multi-tenancy on the database layer or model layer

• apartment tenancy on database layer: https://github.com/influitive/apartment.
• actsastenant tenancy on model layer: https://github.com/ErwinM/actsastenant.

Using Apartment gem

Let’s create a new Rails app

rails new blog-post -d postgresql

cd blog-post

bundle exec rake db:create

Adding the Apartment gem to your Gemfile

Now open up the Gemfile in your rails app and add,

gem 'apartment'

Now generate the apartment config file,

bundle exec rails g apartment:install

This will create a config/initializers/apartment.rb file as the configuration file for us. There is a bunch of configuration stuff to use.

Create the model

For example usage, we will be creating models author and post.

bundle exec rails g model user name

bundle exec rails g model article content

class CreateUsers < ActiveRecord::Migration[5.1]
  def change
    create_table :users do |t|
      t.string :name, null: false
    end
    add_index :users, :name, unique: true
  end
end

validates :name, presence: true, uniqueness: true

bundle exec rails db:migrate

class User < ApplicationRecord
  validates :name, presence: true, uniqueness: true
  after_create do |user|
    Apartment::Tenant.create(user.name)
  end
  after_destroy do |user|
    Apartment::Tenant.drop(user.name)
  end
end

Specify common models

--------------------------
Apartment.configure do |config|
# Add any models that you do not want to be multi-tenanted, but remain in the global (public) namespace.
# A typical example would be a Customer or Tenant model that stores each Tenant's information.
config.excluded_models = %w{ User }
--------------------------

Specify tenant names

config.tenant_names = lambda { User.pluck(:name) }

Specify a middleware

Rails.application.config.middleware.use Apartment::Elevators::Subdomain

See it works

User.create (name: 'Angel')
User.create (name: 'Sam')

Apartment::Tenant.switch!('Angel')

Article.create(content: "Angel’s article")
Article.all
=> #<ActiveRecord::Relation [#<Article id: 1, content: "Angel’s article",
created_at: "2018-01-09 09:30:15", updated_at: "2018-01-09 09:30:15">]>

Apartment::Tenant.switch!('Sam')
Article.all
=> #<ActiveRecord::Relation []>

User.all
=> #<ActiveRecord::Relation [#<User id: 1, name: "Angel">, #<User id: 2, name: "Sam">]>

References

• https://github.com/influitive/apartment

hash = { a: 1, b: 2 }
=> {:a=>1, :b=>2}
hash.transform_keys { |k| k.to_s }
=> {"a"=>1, "b"=>2}
hash
=> {:a=>1, :b=>2}

hash = { a: 1, b: 2 }
=> {:a=>1, :b=>2}
hash.transform_keys! { |k| k.to_s } 
=> {"a"=>1, "b"=>2}
hash
=> {"a"=>1, "b"=>2}

• Array#prepend and Array#append

>> a = ["hello"]
=> ["hello"]
>> a.append "world"
=> ["hello", "world"]
>> a.prepend "Hi"
=> ["Hi", "hello", "world"]

• Added yield_self method

"Hello".yield_self { |obj| obj + " World"}
=> "Hello World"
"Hello".tap { |obj| obj + " World" }
 => "Hello"

• rescue/else/ensure are allowed inside do/end blocks without begin/end

[1].each do |n|
  n / 0
rescue
  # rescue
else
  # else
ensure
  # ensure
end

• String#delete_prefix/delete_suffix

'HelloWorld'.delete_prefix('Hello')
=> "World" 
'HelloWorld'.delete_suffix('World')
=> "Hello"

• Ruby 2.5 has removed top-level constant lookup

class Book;
end
class Seller;
end
 
Book::Seller

Book::Seller
#=> NameError: uninitialized constant Book::Seller
#   Did you mean?  Seller

• New method to ERB to allow assigning the local variables from a hash

require 'erb'
require 'ostruct'
 
namespace = OpenStruct.new(a: 10, b: 3)
template = 'Result: <%= a * b %>'
ERB.new(template).result(namespace.instance_eval { binding })
#=> "Result: 30"

require 'erb'
result = 'Result: <%= a * b %>'
ERB.new(result).result_with_hash(a: 10, b: 3)
#=> "Result: 30"

• Dir.children and Dir.each_child

Dir.entries("/home")
=> ["..", "user", "."]

Dir.foreach("/home") { |child| puts child }
..
user
.

Dir.children("/home")
=> ["user"]

Dir.each_child("/home") { |child| puts child }
user

• Imported features from ActiveSupport library

{a: 1, b: 2, c: 3}.slice(:a, :b)
#=> {:a=>1, :b=>2}

Further changes

References

• https://github.com/ruby/ruby/blob/v2_5_0/NEWS
• https://www.ruby-lang.org/en/news/2017/12/25/ruby-2-5-0-released/

Client libraries are developed by API developer or the community.

There are several HTTP client libraries in Ruby such as:

• HTTParty

• Faraday

• Built-in Net::HTTP

• Rest-Client

• HTTPClient

Among them, the favorite of mine is Faraday gem. Faraday has adapters for popular libraries like Net::HTTP. It is simple, flexible and supports multiple backends and embraces the concept of Rack middleware when processing the request/response cycle. Also, it’s possible to customize its behavior with middleware. We will use a connection object to start with Faraday as it’s more flexible way than a simple getrequest.

conn = Faraday.new
response = conn.get 'http://localhost:3000/tasks'

Using this connection object, we make HTTP requests.

params = {:title => 'Faraday gem', :created_by => 'blog'}
conn.post('http://localhost:3000/tasks',params)

This will POST  title = ‘Faraday gem’  and created by = ‘blog’ to http://localhost:3000/tasks. All HTTP verb methods can take an optional block that will yield aFaraday::Request object.

 conn.post do |req|
   req.url '/tasks'
   req.headers['Content-Type'] = 'application/json'
   req.body = '{"some": "content"}'
 end

Authentication

Basic and Token authentication are handled by Faraday::Request::BasicAuthentication and Faraday::Request::TokenAuthentication respectively. These can be added as middleware manually or through the helper methods.

conn.basic_auth('username', 'password')
conn.token_auth('token')

Proxies

To specify an HTTP proxy:

Faraday.new(:proxy => 'http://proxy.example.com:80/')

Using a different HTTP Adapter

Faraday provides an interface between our code and adapter. Sometimes we may want to use features that are not covered in Faraday’s interface. In such cases, we can have access to features specific to any of the adapters supported by Faraday, by passing a block when specifying the adapter to customize it. For example, you can switch to the HTTPClient adapter as below

 conn = Faraday.new do |builder|
   builder.adapter :httpclient do |client| # yields HTTPClient
     client.keep_alive_timeout = 20
   end
 end

Like this, we can switch to any of the supported adapters. The block parameters will change based on the adapters we are using.

Faraday::Connection object middlewares

A Faraday::Connection object has a list of middlewares, just like a Rack app. Faraday middlewares are passed as an env hash. It has request and response information.

conn = Faraday.new
conn.builder
=> #<Faraday::RackBuilder:0x0000000155d1f0 @handlers=[Faraday::Request::UrlEncoded,
   #Faraday::Adapter::NetHttp]>

Faraday::Builder is similar to Rack::Builder. A new Faraday::Connectionobject is initialized. It has middlewares Faraday::Request::UrlEncoded in front of an adapter Faraday::Adapter::NetHttp.  Like a Rack application, the adapter at the end of the builder chain is what actually executes the request. Middlewares are grouped into request middlewares, response middlewares, and adapters.

Faraday.new do |builder|
  builder.request :retry
  builder.request :basic_authentication, 'login', 'pass'
  builder.response :logger
  builder.adapter :net_http
end

Advanced Middleware Usage

The order in which middleware is stacked in Faraday is like in Rack. The first middleware on the list wraps all others, while the last middleware is the innermost one, so that’s usually the adapter.

conn = Faraday.new(:url => 'https://redpanthers.co/') do |builder|
  # POST/PUT params encoders:
  builder.request :multipart
  builder.request :url_encoded
  builder.adapter :net_http
end

Middlewares stack is manipulated by the Faraday::Builder instance. Each Faraday::Connection instance has a Faraday::Builder instance.

conn = Faraday.new
conn.builder.swap(1, Faraday::Adapter::HTTPClient)
# replace adapter
conn.builder.insert(0, MyCustomMiddleware)
# add middleware to beginning
conn.builder.delete(MyCustomMiddleware)

Writing middleware

Middlewares are classes that respond to call. When middleware is executing, it’s passed as an env hash that has request and response information. Middleware wrap the request/response cycle. The general interface for a middleware is:

class CustomizedMiddleware
  def call(env)
    # do something with the request
    @app.call(env).on_complete do |env|
    # do something with the response
    end
  end
end

All processing of the response should be done in the on-complete block. This enables middleware to work in parallel mode when many requests are occurring at the same time. After the on_complete block, env[:response] is filled in. Faraday::Response instance will be available only after `on_complete`.
faraday-middleware  is a collection of various Faraday middlewares for Faraday-based API wrappers.
For testing middleware, Faraday::Adapter::Test is an HTTP adapter middleware that lets you to fake responses.

References

• https://github.com/lostisland/faraday

]]>

It seems easy, right?

1. I’m happy to watch a new movie
2. I hate war

• I’m happy and excited to be going to watch a new movie

• I hate war and the violence it makes

• Ice cream shops are doing great even when the weather is bad

When SA turns hard

Using Natural Language Processing

• Spell check and grammar check
• Predictive text
• Auto summarization
• Machine translation
• Sentiment analysis

Some common approaches to sentiment analysis

Tools & Libraries

We too have tools……

Sentimental gem

gem install sentimental

 require "sentimental"
 analyzer = Sentimental.new
 analyzer.load_defaults
 sentiment = analyzer.sentiment 'Be the reason someone smiles today'
 score = analyzer.score 'Be the reason someone smiles today'
 puts sentiment, score

positive
0.225

 require "sentimental"
 analyzer = Sentimental.new
 analyzer.load_defaults
 sentiment = analyzer.sentiment 'Icecream shops are doing good even at bad weather'
 score = analyzer.score 'Icecream shops are doing good even at bad weather'
 puts sentiment, score

negative
-0.4194

Sentimentalizer gem

 gem install sentimentalizer

 require "sentimentalizer"
 Sentimentalizer.setup
 class Analyzer
   def initialize
     Sentimentalizer.setup
   end
   sentiment = Sentimentalizer.analyze('I love Ruby', true)
   puts sentiment
 end

 Training analyser with +ve sentiment
 +ve sentiment training complete
 Training analyser with -ve sentiment
 -ve sentiment training complete
 {"text":"I love Ruby","probability":0.8568115588520226,"sentiment":":)"}

Classifying with Bayesian and SVM classifiers

When we need more…

JRuby

Sentiment Analysis using Tensorflow Ruby API

Reference

• https://github.com/malavbhavsar/sentimentalizer
• https://github.com/7compass/sentimental
• https://github.com/diasks2/ruby-nlp

When should we refactor?

class WebsitesController < ApplicationController
  def create
    create_website
    find_or_create_user
    fetch_rank
    redirect_to root_url
  end
  def destroy
    .........
  end
.............
  private
  def create_website
    @website = website.first_or_create
    CollectionWebsite.create(collection_id: collection_id, website_id: website.id)
    @website.fetch_meta_description
  end
  def find_or_create_user
    site_urls = user.websites.map(&:url)
    websites_count = user.websites.count
    user.update!(sites: site_urls, site_number: websites_count)
  end
  def fetch_rank
    return if website.alexaranks.any?
    FetchRankJob.perform_later(website)
  end
 end

Moving a big controller’s action to service objects

class WebsitesController < ApplicationController
  def create
    Websites::Create.call(website_params, current_user)
    redirect_to root_url
  end
  ..........
  def destroy
    Websites::Delete.call(website_params, current_user)
    redirect_to root_url
  end
  ..........
  private
  def website_params
    params.require(:website).permit(:url, :collection_id)
  end
end

module Websites
  class Create
    # From the controller, use it like this:
    # Websites::Create.call(params, user)
    def self.call(params, user)
      new(params, user).call
    end
    def initialize(params, user)
      @params = params
      @user = user
      @website = Website.where(url: params[:website][:url])
    end
    def call
      create_website
      find_or_create_user
      fetch_rank
    end
    private
    attr_reader :params, :user, :website
    def create_website
      @website = website.first_or_create
      CollectionWebsite.create(collection_id: collection_id, website_id: website.id)
      @website.fetch_meta_description
    end
    def find_or_create_user
      site_urls = user.websites.map(&:url)
      websites_count = user.websites.count
      user.update!(sites: site_urls, site_number: websites_count)
    end
    def fetch_rank
      return if website.alexaranks.any?
      FetchRankJob.perform_later(website)
    end
  end
end

While refactoring, at each step we have to make sure that none of our tests failed.

Partials and helpers

<% if @user && @user.post.present? %>
  <%= @user.post %>
<% end %>

module SiteHelper
  def user_post(user)
    user.post if user && user.post.present?
  end
end

<%= user_post(@user) %>

References

• https://github.com/adamniedzielski/service-objects-example

• Native WebSocket support
• Compiles to efficient native code
• Statically typed => if any errors it will let you know at compile time.
• Less memory consumption

Web frameworks in Crystal

crystal init app sample-app

Kemal

Install Kemal

shards install

require "kemal"
# Matches GET ""
get "/" do
"Hello World!"
end
Kemal.run

crystal run src/sample-app.cr

Amethyst

Amber

git clone https://github.com/amber-crystal/amber.git

cd amber

shards install

make

dependencies:
  granite_orm:
    github: Amber-Crystal/granite-orm

Kemalyst

Raze

• Two matching routes that both having a block is not possible

get "/hello*" do |ctx|
  do_something
end
get "/hello/raze" do |ctx|
  "hello, raze"
end

get "/hello*", DoSomething.new

get "/hello*", DoSomething.new
get "/hello/raze" do |ctx|
  "hello, raze"
end

• Route ambiguity order

Limitations

Conclusion

Reference

• https://github.com/veelenga/awesome-crystal#web-frameworks

Friendly error messages

import Html exposing(..)
view orders =
  div [] (List.mapp viewOrder orders)
viewOrder order =
  span [] (text order.name)

--NAMING ERROR-----------------------------------------------------list-mapp.elm
Cannot find variable 'List.mapp' .
6| div [] (List.mapp viewOrder orders)
List does not expose 'mapp' . May be you want one of the following?
List.map
List.any
List.map2
List.map3

• shows the line number in the code which caused the error
• shows the actual line of code
• lists the maximum possibilities for correct code

• React
• Redux
• npm/yarn
• Webpack
• Immutable.JS

Start with Elm

Architecture

Install on Rails

rails new elm-on-rails --webpack=elm

./bin/rails webpacker:install:elm

#hello_elm.js
import Elm from './Main'
document.addEventListener('DOMContentLoaded', () => {
const target = document.createElement('div')
document.body.appendChild(target)
Elm.Main.embed(target)
})

<%= javascript_pack_tag "hello_elm" %>

#config/routes.rb
get '/', to: 'application#index'

bundle exec rails webpacker:compile

Immutable Data and Pure Functions

user.update(params)

new_hash = hash.merge(params)

newUser = update params user

Elm Platform

• elm-repl

• elm-reactor

elm-reactor -a 0.0.0.0 -p 3000

• elm-make

• elm-package

elm-package install <package-name>

References

• https://github.com/rails/webpacker
• https://guide.elm-lang.org/
• https://www.elm-tutorial.org/en/
• https://github.com/fbonetti/elm-rails

Threads in Ruby

def add_elements(group)
  sleep(4)
  sum = 0
  group.each do |item|
    sum += item
  end
  sum
end
@group1 = [22, 44, 55]
@group2 = [45, 59, 72]
@group3 = [99, 22, 33]
puts "sum of group1 = #{add_elements(@group1)}"
puts "sum of group2 = #{add_elements(@group2)}"
puts "sum of group3 = #{add_elements(@group3)}"

threads = (1..3).map do |c|
  Thread.new(c) do |c|
    groups = instance_variable_get("@groups#{element}")
    puts "groups#{element} = #{add_element(groups)}"
  end
end
threads.each {|t| t.join}

Queue for managing threads

require 'thread'
queue = Queue.new
Thread.new do
  4.times do |i|
    sleep(2)
    queue << i
    puts "Thread #{i} produced"
  end
end

Thread 0
Thread 1
Thread 2
Thread 3

Thread.new do
  4.times do |i|
     sleep(2)
     puts "consumed thread #{queue.pop}"
  end
end

Thread 0
consumed 0
Thread 1
consumed 1
Thread 2
consumed 2
Thread 3
consumed 3

Sized queue for fixed-length queue

require 'thread'
queue = Queue.new
Thread.new do
  10.times do |i|
    sleep(2)
    queue << i
    puts "Thread #{i} produced"
  end
end
Thread.new do
  4.times do |i|
    sleep(2)
    puts "consumed thread #{queue.pop}"
  end
end

require 'thread'
queue = SizedQueue.new(4)
Thread.new do
  10.times do |i|
    sleep(2)
    queue << i
    puts "Thread #{i}"
  end
end
Thread.new do
  4.times do |i|
    sleep(2)
    puts "consumed #{queue.pop}"
  end
end

Thread 0 produced 
consumed thread 0
Thread 1 produced 
consumed thread 1
Thread 2 produced 
consumed thread 2
Thread 3 produced 
consumed thread 3
Thread 4 produced 
Thread 5 produced 
Thread 6 produced 
Thread 7 produced

References

• https://docs.ruby-lang.org/en/2.4.0/Queue.html
• https://docs.ruby-lang.org/en/2.4.0/SizedQueue.html

To start with Pundit

gem 'pundit'

include Pundit

rails g pundit:install

#app/policies/application_policy.rb
class ApplicationPolicy
  attr_reader :user, :record
  def initialize(user, record)
    @user = user
    @record = record
  end
  #............
  def destroy?
    false
  end
  def scope
    Pundit.policy_scope!(user, record.class)
  end
  class Scope
    attr_reader :user, :scope
    def initialize(user, scope)
      @user = user
      @scope = scope
    end
    def resolve
      scope
    end
  end
end

Create policies

def pundit_user
  User.find_by_other_means
end

class User < ApplicationRecord  
  has_many :collections, dependent: :destroy
end

class Collection < ApplicationRecord  
  belongs_to :user
end

#app/policies/collection_policy.rb
class CollectionPolicy < ApplicationPolicy
  def destroy?
    record.user == user
  end
end

record.user == user

class CollectionsController < ApplicationController
  protect_from_forgery
  def create
    Collections::Create.call(collection_params, current_user)
    redirect_to root_url
  end
  def destroy
    collection = Collection.find(params[:id])
    authorize(collection, :destroy?)
    Collections::Delete.call(collection, current_user)
    redirect_to root_url
  end
  private
  def collection_params
    params.require(:collection).permit(:name)
  end
end

Policy without a corresponding model

# app/policies/website_policy.rb
class WebsitePolicy < Struct.new(:user, :website)
  # ...
end

# In controllers
authorize :website, :show?

# In views
<% if policy(:website).show? %>
  <%= link_to 'Website', website_path %>
<% end %>

Pundit scopes

class Scope < Scope
  def resolve
    if user.admin?
      scope.all
    else
      scope.where(:company_id => user.collections.select(:website_id))
    end
  end
end

def index
  @websites = policy_scope(Website.includes(:company).all)
  authorize @websites
end

Exception handling

class ApplicationController < ActionController::Base
  include Pundit
  protect_from_forgery with: :exception
  rescue_from Pundit::NotAuthorizedError, with: :user_not_authorized
  def user_not_authorized
    flash[:alert] = 'You are not authorized to perform this action.'
    redirect_back(fallback_location: root_path)
 end
end

Why Pundit?

• Well suited to the service oriented architecture that’s popular for large Rails applications
• Keep controllers skinny
• Pundit policy objects are lightweight, adding authorization logic without as much overhead as CanCanCan
• Emphasizes object-oriented design with discrete Ruby objects providing specialized services

References

• Pundit Gem on Github
• Rails-Devise-Pundit

Screenshots with PhantomJS

gem install phantomjs

var instance = require('webpage').create();

instance.open('http://redpanthers.co/', function() {
instance.render('screenshot-phantom.png');
phantom.exit();
});

phantomjs filename.js

Screencap gem

gem install phantomjs -v 1.9.8

phantomjs --version

gem 'screencap'

gem install screencap

Usage

require 'screencap'
screenshot = Screencap::Fetcher.new(<url>)
image = screenshot.fetch

• Fetcher class accepts url of the website to take screenshot.
• Screenshot is taken when fetch method is called.
• Also, fetch method supports various optional parameters to specify the area to capture the screenshot.
• We can specify where to store the screenshot captured, as shown below.

image = obj.fetch(
 output: '~/folder/file-name.png',
 # dimensions for taking screenshot of specific area
  width: 1024,
 height: 768
 )

Example

require 'screencap'
screenshot = Screencap::Fetcher.new('http://redpanthers.co/')
image = screenshot.fetch(output: '~/screencap/screencap.png',
                                   width: 300,
                                  height: 500)

Webshot gem

gem 'webshot'

gem install webshot

Usage

require 'webshot'
screenshot = Webshot::Screenshot.instance
screenshot.capture "https://github.com/", "image.png", width: 1024, height: 800

References

• PhantomJS
• Screencap gem
• Webshot gem