• Has date attributes only (year, month, day)
• Based on integer whole-day intervals from an arbitrary “day zero”
• Can handle date arithmetic in units of whole days
• Date object is created with ::new, ::jd, ::ordinal, ::commercial, ::parse, ::strptime, ::today, Time#to_date etc.
• Takes 4 bytes to store.

$ require 'date'
$ Date.new(2001,2,3)
  Date: 2001-02-03
$ Date.jd(2451944)
  Date: 2001-02-03 ...
$ Date.ordinal(2001,34)
  Date: 2001-02-03 ...
$ Date.commercial(2001,5,6)
  Date: 2001-02-03 ...
$ Date.parse('2001-02-03')
  Date: 2001-02-03 ...
$ Date.strptime('03-02-2001', '%d-%m-%Y')
  Date: 2001-02-03 ...
$ Time.new(2001,2,3).to_date
  Date: 2001-02-03 ...
$ Date.today
  "Mon, 02 Jan 2017"

Time

• Has date and time attributes (year, month, day, hour, min, sec, subsec)
• Can handle negative times before unix time
• Can handle time arithmetic in units of seconds

$ require 'time'
$ Time.now
   2015-12-08 10:26:40 -0200
$ time = Time.new
  Components of a Time
$ time.year    # => Year of the date
$ time.month   # => Month of the date (1 to 12)
$ time.day     # => Day of the date (1 to 31 )
$ time.wday    # => 0: Day of week: 0 is Sunday
$ time.yday    # => 365: Day of year
$ time.hour    # => 23: 24-hour clock
$ time.min     # => 59
$ time.sec     # => 59
$ time.usec    # => 999999: microseconds
$ time.zone    # => "UTC": timezone name

DateTime

• Has date and time attributes (year, month, day, hour, min, sec)
• It  is formatted as YYYY-MM-DD HH:MM:SS
• Based on fractions of whole-day intervals from an arbitrary “day zero” (-4712-01-01)
• Can handle date arithmetic in units of whole days or fractions
• Takes 8 bytes to store, and has a precision of .001 seconds.
  • A four-byte integer packed as YYYY×10000 + MM×100 + DD
  • A four-byte integer packed as HH×10000 + MM×100 + SS
• Valid ranges go from the year 1000 to the year 9999
• It is created with ::new, ::jd, ::ordinal, ::commercial, ::parse, ::strptime, ::now, Time#to_datetime etc.

$ require 'date'
$ DateTime.new(2001,2,3,4,5,6)
  DateTime: 2001-02-03T04:05:06+00:00 ...

Let’s see the Differences among all of them which makes them unique.

• Date use rational and a “day zero” for storage. But Time doesn’t. So Time is faster.
• Date field is populated with a literal date and does not concern itself with time zones so this can cause trouble if it is not expressed in the user’s local time. A DateTime can always be converted to a user’s local time if required.
• Time used to track changes to records and update every time when the record is changed. DateTime used to store a specific and static value which is not affected by any changes in records.
• Time internally converted current time zone to UTC for storage, and during retrieval converted back to the current time zone. DateTime can not do this.
• Time affected by different TIME ZONE related setting. Datetime is constant.
• Ruby’s Time class implements a proleptic Gregorian calendar and has no concept of calendar reform. This problem can be overcome using DateTime class.

References

• https://ruby-doc.org/stdlib-2.4.0/libdoc/date/rdoc/Date.html
• http://stackoverflow.com/questions/3928275/in-ruby-on-rails-whats-the-difference-between-datetime-timestamp-time-and-da
• https://www.tutorialspoint.com/ruby/ruby_date_time.html
• http://stevenyue.com/blogs/date-time-datetime-in-ruby-and-rails/

• If the request matches any safelist, it is allowed.
• If the request matches any blocklist, it is blocked.
• If the request matches any throttle, a counter is incremented in the Rack::Attack.cache. If any throttle’s limit is exceeded, the request is blocked.
• Otherwise, all tracks are checked, and the request is allowed.

Implementation

gem 'rack-attack'

# In config/application.rb
config.middleware.use Rack::Attack

# In config.ru
use Rack::Attack

class Rack::Attack
  Rack::Attack.cache.store = ActiveSupport::Cache::MemoryStore.new
  ########
end

Throttle

throttle('api/ip', limit: 3, period: 10) do |req|
  req.ip
end

Safelist

Rack::Attack.safelist('allow from localhost') do |req|
  '127.0.0.1' == req.ip
end

Blacklist

Rack::Attack.blacklist('block 2.2.2.2') do |req|
  '2.2.2.2' == req.ip
end

Fail2Ban: Fail2Ban.filter can be used within a blocklist to block all requests from misbehaving clients. Allow2Ban: Allow2Ban.filter works the same way as the Fail2Ban.filter except that it allows requests from misbehaving clients until such time as they reach maximum retry.

Block logins from a bad user agent

Rack::Attack.blacklist('block bad UA logins') do |req|
  req.path == '/login' && req.post? && req.user_agent == 'BadUA'
end

Tracks

Rack::Attack.track("special_agent") do |req|
  req.user_agent == "SpecialAgent"
end

Security issues that Rack Attack addresses

• Rate limits against DDoS and abusive users

DDoS is short for Distributed Denial of Service. It uses multiple computers and Internet connections to flood the targeted resource.

Whitelist Search Engine spiders

        Though we blacklist IP’s that are misbehaving, we have to whitelist search engine spiders. But they have a huge range of IP’s. So we can check user agent. But it’s something anyone can fake. We can run a reverse DNS lookup of the accessing IP and perform a forward DNS lookup on the domain (using host command). Verify that it is same as the original IP address from the logs.

References

• https://www.diycode.cc/projects/kickstarter/rack-attack
• https://searchcode.com/file/86455896/README.md
• http://sourcey.com/building-the-prefect-rails-5-api-only-app/

Git Graphs

git log --graph --decorate --oneline

The –graph option draws a graph representing the branches and its structure of commit history. –oneline is used to display commit message and its hash in a single line, which is used along with –decorate, which helps us to easily see which commit belongs to which branch.

Custom formatting

git log --pretty=format:"<string>"

git log --pretty=format:"%cn committed %h on %cd"

Filtering the output

By amount

git log -<n>

git log -3

By date

git log --after=<date>
git log --before=<date>

git log --after='24-10-2016'
or
git log --since='24-10-2016'

git log --date=<option>

By Author

git log --author=<name>

git log --author='John\| Mary'

By message

git log --grep='<message>'

By file

git log -- something.rb incredible.rb

By Content

git log -S"Hello World!"

Format options available

git log --pretty=format:'<options>'

%H  - Commit hash
%h  - Abbreviated commit hash
%T  - Tree hashes
%t  - Abbreviated tree hash
%P  - Parent hashes
%p  - Abbreviated parent hashes
%an - Author name
%ae - Author email
%ad - Author date (format respects the --date=option)
%ar - Author date, relative
%cn - Committer name
%ce - Committer email
%cd - Committer date
%cr - Committer date, relative
%s  - Subject
%B  - Message

git log --pretty=format:"%B on %ad with hash %h by %an" --date=short