inat-get 0.8.0.16 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8f300ef3ec85bd4a168f2d4cbda6cc8ed922bb080c3e7de57685e6d753e58ae
-  data.tar.gz: 9e7cb3ddacd711e9d7b79c273e2f0811f698bb3596ed7421893335d2c525252e
+  metadata.gz: dbe428cb94175725066a61cdb1022523cba2a0e429613458ec532e4301432c8b
+  data.tar.gz: 82ce8aa99fe0dfe48da6e8c0d0fc7193a4b6a90e794815939862aca0105fc44e
 SHA512:
-  metadata.gz: 190b1940be2c402d2b5ec8092618276f362b9d8eab8a732aa1dd439bc396240189fbb587dd3d7398fc67183c8d4d2c070ef791137bce967c264176ec0c914c3f
-  data.tar.gz: 8356abb7580c8c43d8dd603eaa6a7e2e7a4b9d0bb72320104cdf699f170cbb7d1fb0938e1a7db350cb5515c9e74dba6237ddfa059f1fd705a1eb411f73dd6c2c
+  metadata.gz: 56e50506345683d97dbb93d97b9aa6c2c45b3d162feb1114959a24fb799500ed2a104762f438408e8148a86288cba4e99b0bd77557b9d358e8068a58ed370c8b
+  data.tar.gz: 37151bf35d79d932ec90bb737bac4f2dbefbae596dc3af368a29c7a791a3c4b383f03031f5911c6555208e5e53322e0acf7fa90c0f41bdbc917e196310e80458

data/README.md

@@ -1,16 +1,284 @@
-<img src="docs/logo.png" align="right" style="float:right;width:57%;">
+# 🌿 inat-get
 
-# INat::Get
+[![GitHub License](https://img.shields.io/github/license/inat-get/inat-get)](LICENSE)
+[![Gem Version](https://badge.fury.io/rb/inat-get.svg?icon=si%3Arubygems&d=1)](https://badge.fury.io/rb/inat-get)
+[![Ruby](https://github.com/inat-get/inat-get/actions/workflows/ruby.yml/badge.svg)](https://github.com/inat-get/inat-get/actions/workflows/ruby.yml) 
+![Coverage](coverage-badge.svg)
 
-A toolset for fetching and processing data from **[iNaturalist.org][inat]**.
+## What is this and why?
 
-The author of this software is not associated or affiliated with the iNaturalist.
-Only the [public API][api] is used in accordance with [the conditions][cond].
+`inat-get` is a utility for fetching and analyzing data from **[iNaturalist](https://www.inaturalist.org/)**.
 
-[inat]: https://www.inaturalist.org/
-[api]: https://api.inaturalist.org/v1/docs/
-[cond]: https://api.inaturalist.org/v1/docs/#terms-of-use
+The basic approach is to form queries as *declaratively* as possible and get reports,
+without giving up advanced capabilities. This leads us to the concept of **{file:DSL.md DSL — Domain Specific Language}** —
+and user scripts using it. It is assumed that the user will need a *minimal*
+familiarity with Ruby syntax, but if desired, they can use the full power of the language.
 
-## Current status
+The second crucial aspect is **caching**, designed to minimize duplication of
+requested data without compromising freshness. For caching, a local database is used,
+which potentially can be from a fairly wide range of supported DBMS: SQLite, PostgreSQL, MySQL
+and others.
 
-Early alpha version.
+*However, it should be noted that version 0.9.0 was tested only on SQLite3, full testing
+with various DBMS is planned for version 0.9.4...*
+
+The third key point is **parallel execution** of multiple user scripts: first,
+almost all computers are multi-core now, and second, while one is waiting for a response from the API, others can
+calmly do processing. At the same time, the API requests themselves go through a single synchronous point to strictly
+comply with the restrictions imposed by the iNaturalist API itself, and not get banned for incorrect use.
+
+### What is not and will not be
+
++ *Authorization and data submission.* This is a tool for analysis, not for automating any actions
+  with iNaturalist.
+
++ *Neural network integration.* Strict analytics and neural networks should not be mixed. Of course, integration
+  "from the other side" is possible, i.e., fetching data and then using them with neural networks.
+
++ *Native versions for other systems.* Currently the script works only on Linux (though possibly under
+  other unix-like systems, not checked). Native cross-platform support is not planned, but containerization
+  is planned (though not soon), which will allow expanding usage.
+
+## Current status and plans
+
++ **v0.8.x**
+
+  Outdated versions. Due to poorly thought-out architecture, it works very slowly and caches very poorly.
+  Can be used, but shouldn't be.
+
++ **[v0.9.0](https://github.com/inat-get/inat-get/milestone/4)** *(current development)*
+
+  Architectural problems are solved, but because of them the project had to be rewritten almost from scratch, and a lot remains
+  to be done.
+
+  *This is more of a beta than an alpha, but a very early beta.*
+
+  The main unfinished piece is the absence of a report formatting system. Below in the [Examples](#examples) section you can
+  see how this is worked around... Besides, not all query types are implemented and caching is unfinished
+  in terms of updating *old* data.
+
++ **[v0.9.2](https://github.com/inat-get/inat-get/milestone/5)**
+
+  Planning to add ERB support for reports. It's not a huge step forward compared to
+  direct file writing, but it will add some convenience.
+
++ **[v0.9.4](https://github.com/inat-get/inat-get/milestone/6)**
+
+  Planning to conduct extensive load testing on different DBMS (at least SQLite and PostgreSQL),
+  followed by corrections and optimizations.
+
+  That is, version 0.9.4 is planned as a strictly corrective and optimizing release without adding new functionality.
+
++ **[v0.9.6](https://github.com/inat-get/inat-get/milestone/7)**
+
+  Here the completion of work with queries is planned — implementation of missing ones, finalization of the caching system, etc.
+
++ **[v0.9.8](https://github.com/inat-get/inat-get/milestone/8)**
+
+  This version is planned for the development and debugging of a general reporting system. It's not yet entirely clear what exactly
+  it will be, the task is in `research` status...
+
++ **[v1.0](https://github.com/inat-get/inat-get/milestone/9)** <u>(release)</u>
+
+  Basically, everything above, refactored and polished. Of the serious changes visible to the user,
+  only *containerization* and, through it, cross-platform support is planned.
+
++ **[v1.2](https://github.com/inat-get/inat-get/milestone/10)** 
+
+  Plans are not yet fully formed and will change. In versions after 1.0, advanced
+  capabilities are planned to be added, the exact composition of which will become clearer in the process of real usage.
+
++ **v2.0**
+
+  Very uncertain future, by that time the iNaturalist API will likely have changed, and completely
+  new needs will have appeared...
+
+## Installation and usage
+
+### Installation
+
+The project is packaged as a Ruby Gem, so it is installed accordingly:
+```shell
+$ gem install inat-get
+```
+
+However, if you want to use the current version "from sources", you can simply clone the repository
+and run `bundle install`:
+```shell
+$ git clone https://github.com/inat-get/inat-get.git
+$ cd inat-get
+$ bundle install
+```
+
+And then run via `bundle exec`:
+```shell
+$ bundle exec inat-get [options] ‹task› [‹task› ...]
+```
+
+### Command line parameters
+
+<pre><b>$</b> bundle exec inat-get --help
+🌿 <b>iNatGet v0.9.0:</b> iNaturalist API query builder and analytics tool
+          License: <b>GNU GPLv3+</b> (https://github.com/inat-get/inat-get/blob/main/LICENSE)
+           Author: <b>Ivan Shikhalev</b> (https://github.com/shikhalev)
+         Homepage: <b>https://github.com/inat-get/inat-get</b>
+
+   <b>Usage:</b> inat-get [options] ‹task› [‹task› ...]
+
+   <b>Info Options:</b>
+    -h, --help                       Show this help and exit.
+        --version                    Show version and exit.
+    -i, --info                       Show information about DB status and API connection. 
+                                       Then exit.
+        --show-config                Show current configuration and exit.
+
+   <b>Main Options:</b>
+    -c, --config FILE                Use this file as config (must be YAML) 
+                                       [default: ~/.config/inat-get.yml].
+    -l, --log-level LEVEL            Log level (fatal, error, warn, info or debug) 
+                                       [default: warn].
+        --debug                      Set log level to debug.
+    -o, --offline                    Offline mode: no updates, use local database only.
+    -O, --online                     Online mode [default], use this flag to cancel 
+                                       'offline: true' in config.
+
+   <b>DB Maintenance:</b>
+    -C, --db-check                   Check DB version and exit.
+    -U, --db-update                  Migrate to latest DB version and exit.
+    -M, --db-migrate VER             Migrate to DB version VER and exit.
+        --db-create                  Create database (error if exists).
+        --db-reset                   Drop (if exists) and recreate database. All fetched 
+                                       data will be lost.
+
+   <b>File Arguments:</b>
+        ‹task› [‹task› ...]          One or more names of task files or list files with '@' 
+                                      prefix (one task file per line). If task name has not 
+                                      extension try to read '‹task›' than '‹task›.inat' than 
+                                      '‹task›.rb'.
+</pre>
+
+### DSL
+
+So, in scripts you can (and should) use specially prepared DSL methods and objects
+responsible for data.
+
+First of all, these are **models**, documentation for which can be found at
+<https://inat-get.github.io/inat-get/INatGet/Data/Model.html>. In general, these are simply data
+objects linked to each other. The key ones are probably:
+[`Observation`](https://inat-get.github.io/inat-get/INatGet/Data/Model/Observation.html),
+[`Taxon`](https://inat-get.github.io/inat-get/INatGet/Data/Model/Taxon.html),
+[`Project`](https://inat-get.github.io/inat-get/INatGet/Data/Model/Project.html),
+[`Place`](https://inat-get.github.io/inat-get/INatGet/Data/Model/Place.html)
+and [`User`](https://inat-get.github.io/inat-get/INatGet/Data/Model/User.html).
+
+The main work is built on the arithmetic of **datasets** and **lists**. Datasets are data
+selections, manipulations with which happen without real access to the API and DB until
+it becomes necessary. Lists are datasets split by some key field.
+Documentation is at <https://inat-get.github.io/inat-get/INatGet/Data/DSL/Dataset.html>
+for `Dataset` and <https://inat-get.github.io/inat-get/INatGet/Data/DSL/List.html> for `List`.
+Both classes implement the `Enumerable` module, each in its own way...
+
+At the beginning of each script we make observation selections (usually) via the `select_observations` method.
+In general, `select_*` and `get_*` methods for different object types are described in the DSL module documentation —
+<https://inat-get.github.io/inat-get/INatGet/Data/DSL.html>. In user scripts this
+module is initially included in the context, so its methods are available directly.
+
+*Unfortunately, the fields of selections are not yet documented.* Will be soon.
+
+Below are simple examples of user scripts. It is recommended to pay attention
+to "arithmetic" operations: `+`, `-`, `*` and `%`. The last one performs splitting and turns
+a dataset into a list.
+
+## Examples
+
+### Simple report for a user — [user_stat.rb](share/inat-get/demo/01_user_stat.rb)
+
+```ruby
+# Let's make a simple report on taxa observed by the user since the beginning of the year.
+# The report will be output to the current directory with the name user_stat.md (Markdown format)
+
+year = today.year
+
+user = get_user 'shikhalev'      # Here specify the user ID or login, I specified my own
+
+# Get observations
+observations = select_observations user: user, observed: time_range(year: year), quality_grade: 'research'
+
+by_taxon = observations % :taxon
+
+File::open "#{ name }.md", 'w' do |file|
+  file.puts '## Report for user ' + user.login + (user.name ? " (#{ user.name })" : '')
+  file.puts ''
+  by_taxon.each do |ds|
+    # Here ds.key is a Taxon object
+    file.puts "+ #{ ds.key.common_name } *(#{ ds.key.name })* — #{ ds.count } obs."
+  end
+  file.puts ''
+  file.puts "Total **#{ observations.count }** observations"
+end
+```
+
+### Demonstration of list subtraction — [underbound.rb](share/inat-get/demo/02_underfound.rb)
+
+```ruby
+# And here we implement the following: for a certain area, find a list of taxa
+#  that the given user has not observed (but others have).
+
+user = get_user 'shikhalev'
+place = get_place 'artinskiy-gorodskoy-okrug-osm-2023-sv-ru'
+
+all_observations = select_observations place: place, quality_grade: 'research', rank: (.. Rank.complex)
+full_list = all_observations % :taxon
+
+user_observations = select_observations place: place, quality_grade: "research", rank: (.. Rank.complex), user: user
+user_list = user_observations % :taxon
+
+others_list = full_list - user_list
+others_list.sort! { |ds| -ds.count }
+
+File::open "#{ name }.md", 'w' do |file|
+  file.puts '## Not found by you'
+  file.puts ''
+  others_list.each do |ds|
+    file.puts "+ #{ ds.key.common_name } *(#{ ds.key.name })* — #{ ds.count } obs."
+  end
+  file.puts ''
+  file.puts "Total **#{ others_list.count }** taxa."
+end
+```
+
+### List filtering and date range — [newcomers.rb](share/inat-get/demo/03_newcomers.rb)
+
+```ruby
+# Newcomers of the previous month. As simple as possible: those who made an observation during
+#  the previous month, and registered in it as well. Naturally, within some
+#  project, so as not to pull too much.
+
+project = get_project 'bioraznoobrazie-rayonov-sverdlovskoy-oblasti'
+
+month = today.month - 1
+year = if month == 0
+  month = 12
+  today.year - 1
+else
+  today.year
+end
+
+period = time_range year: year, month: month
+observations = select_observations project: project, created: period
+
+list = observations % :user
+list.filter! { |ds| period === ds.key.created }
+list.sort! { |ds| ds.key.created }
+
+File.open "#{ name }.md", 'w' do |file|
+  file.puts "\#\# Newcomers of project «#{ project.title }»"
+  file.puts "*#{ period.begin.to_date } — #{ period.end.to_date - 1 }*"
+  file.puts ''
+  list.each do |ds|
+    file.puts "+ #{ ds.key.login } (#{ ds.key.created.to_date }) — #{ ds.count } obs."
+  end
+  file.puts ''
+  file.puts "Total #{ list.count } users"
+end
+```

data/bin/inat-get

@@ -1,59 +1,8 @@
-#!/usr/bin/ruby -w
+#!/usr/bin/ruby --jit
 
-require 'date'
-require 'pp'
+require_relative '../lib/inat-get'
+require_relative '../lib/inat-get/app'
 
-# require 'extra/enum'
+app = INatGet::App::Main::instance
 
-require 'inat/app/application'
-require 'inat/app/globals'
-require 'inat/data/entity/observation'
-require 'inat/data/entity/request'
-require 'inat/data/db'
-require 'inat/data/query'
-
-app = INat::Application.new
 app.run
-# PP::pp Globals.config, $>, 64
-
-# puts
-# puts DDL.DDL
-
-# PP::pp DB::instance, $>, 64
-
-# data = API::query(:observations, user_login: 'shikhalev', month: 11)
-
-# PP::pp data.map { |d| Observation::parse(d) }.size, $>, 64
-
-# https://www.inaturalist.org/projects/174222
-# https://www.inaturalist.org/places/193592
-# https://www.inaturalist.org/places/193881 (Ачитский район)
-# https://www.inaturalist.org/places/194104 (Богдановичский район)
-# https://www.inaturalist.org/places/194414 (Качканарский район)
-# https://www.inaturalist.org/places/194023 (Берёзовский район)
-# https://api.inaturalist.org/v1/observations?project_id=176067&updated_since=2023-10-31T19:36:29+05:00&per_page=200&order_by=id&order=asc&locale=ru&preferred_place_id=11829
-
-# W, [2023-11-02T01:54:41.818021 #8118]  WARN -- ‹main›: Some Taxon IDs were not fetched: 48460, 1, 47120, 245097, 47119, 47118, 120474, 342614, 319384, 67599, 495875, 153683, 153680, 367182, 48893, 1252003, 60920!
-# W, [2023-11-02T03:49:58.509031 #8118]  WARN -- ‹main›: Some Taxon IDs were not fetched: 1, 47118, 47119, 47120, 48460, 48893, 60920, 67599, 120474, 153680, 153683, 245097, 319384, 342614, 367182, 495875, 1252003!
-
-# query = Query::new project_id: 180212
-# PP::pp query.observations.size, $>, 64
-
-# require 'inat/data/types/apiquery'
-
-# pp Time::new.to_date.to_s
-
-# a = ApiQuery::new ololo: 1, lalala: UUID.generate
-
-# PP::pp a, $>, 64
-# puts a.to_query
-
-# Request::create ''
-
-# pp URI::parse('https://api.inaturalist.org/v1/observations?project_id=176067&updated_since=2023-10-31T19:36:29+05:00&per_page=200&order_by=id&order=asc&locale=ru&preferred_place_id=11829')
-
-# d = Date::parse '2023-11-01'
-# t = d.to_time
-# i = t.to_i
-
-# pp [ d, t, i ]

data/lib/inat-get/app/application.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'singleton'
+
+require_relative '../info'
+require_relative 'core/console'
+require_relative 'core/api'
+require_relative 'core/task'
+require_relative 'core/worker'
+
+module INatGet::App; end
+
+class INatGet::App::Main
+
+  include Singleton
+
+  def initialize
+    @config = INatGet::App::Setup::config!
+    if @config[:tasks].nil?
+      warn "❌ No tasks specified!"
+      exit Errno::ECHILD::Errno
+    end
+  end
+
+  def run
+    console_socket = @config.dig :socket, :console
+    api_socket = @config.dig :socket, :api
+    check_sockets! api_socket, console_socket
+
+    INatGet::App::Maintenance::db_check @config, true
+
+    console = INatGet::App::Server::Console::create console_socket
+    api = nil
+    api = INatGet::App::Server::API::create api_socket, console: console if !@config[:offline]
+
+    tasks = @config[:tasks].map { |path| INatGet::App::Task::new path, @config, console: console, api: api }
+    Process::warmup
+    INatGet::App::Worker::enqueue @config, *tasks, console: console, api: api
+    console.quit
+    api.quit if api
+  end
+
+  private
+
+  def check_sockets! socket, socket2
+    if File.exist?(socket)
+      if socket_alive?(socket)
+        warn "❌ API Socket already exists!"
+        exit Errno::EEXIST::Errno
+      else
+        File.delete socket
+      end
+    end
+
+    if File.exist?(socket2)
+      File.delete socket2
+    end
+  end
+
+  def socket_alive? socket
+    return false unless File.socket?(socket)
+    INatGet::App::Server::used? socket
+  end
+
+end

data/lib/inat-get/app/core/api.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/retry'
+require 'is-duration'
+
+require_relative 'server'
+require_relative 'console_logger'
+
+class INatGet::App::Server::API < INatGet::App::Server
+
+  def initialize socket_path, **params
+    @console = params.delete :console
+    @logger = ::INatGet::App::ConsoleLogger::new @console, progname: 'API'
+    super(socket_path, **params)
+    @config = INatGet::App::Setup::config
+    @delay = IS::Duration::parse @config.dig(:api, :delay)
+  end
+
+  private
+
+  def get query, **opts
+    endpoint = @config.dig(:api, :root) + query[:endpoint].to_s
+    timepoint = Time::now
+    if @last_request
+      delta = timepoint - @last_request
+      sleep (@delay - delta) if delta < @delay
+    end
+    @last_request = timepoint
+    response = faraday.get(endpoint) do |rq|
+      rq.params[:per_page] = @config.dig(:api, :pager)
+      rq.params.compact!
+      rq.params.merge! query[:query]
+      rq.headers["User-Agent"] = "iNatGet v#{INatGet::Info::VERSION} (#{ INatGet::Info::VERSION_ALIAS })"
+    end
+    if response.success?
+      begin
+        data = JSON.parse response.body, symbolize_names: true
+        return data.freeze
+      rescue => e
+        @logger.error "Error while parsing: #{e.message}"
+        return { status: :error, error: e.message }.freeze
+      end
+    else
+      @logger.error "Error in response: #{response.status}"
+      return { status: :error, error: response.status }.freeze
+    end
+  end
+
+  def faraday
+    # tmp_logger = ::Logger::new 'common.log', level: :info
+    @faraday ||= Faraday::new do |f|
+      f.request :retry,
+                max: @config.dig(:api, :retry, :max),
+                interval: IS::Duration::parse(@config.dig(:api, :retry, :interval)),
+                interval_randomness: @config.dig(:api, :retry, :randomness),
+                backoff_factor: @config.dig(:api, :retry, :backoff),
+                exceptions: [Faraday::TimeoutError, Faraday::ConnectionFailed, Faraday::SSLError, Faraday::ClientError]
+      f.request :url_encoded
+      # f.response :logger, tmp_logger, bodies: true, headers: true
+      f.adapter Faraday::default_adapter
+    end
+  end
+
+end

data/lib/inat-get/app/core/console.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+require 'is-term/statustable'
+require 'is-term/formats'
+require 'is-term/functions'
+
+require_relative 'server'
+
+class INatGet::App::Server::Console < INatGet::App::Server
+
+  def initialize socket_path, **params
+    super(socket_path, **params)
+    @table = IS::Term::StatusTable::instance
+    @table.configure do
+      column :icon, func: lambda { |row| row[:_active] ? "\e[1m[ ]" : "[✔]" }
+      separator '  '
+      column :_sender_pid, id: true, align: :right
+      separator '  '
+      column :name
+      separator '  '
+      column :status, align: :center
+      separator '  '
+      column :current, align: :right, summary: :current
+      separator ' of '
+      column :total, align: :left, summary: :total
+      separator '  '
+      column :percent, align: :right, func: :percent, format: '%d%%', summary: :percent
+      separator '  '
+      column :estimated, func: :estimated, align: :right, format: :duration, summary: :elapsed
+      separator '  '
+      column :speed, func: :speed, format: '%.2f r/s', align: :right, summary: :speed
+      separator '  '
+      column :message, summary: :value
+
+      summary true, message: ''
+    end
+    if @config.dig(:logs, :file, :enable)
+      filename = @config.dig(:logs, :file, :enable)
+      @sys_logger = Logger::new filename, 'daily', 7, level: @config.dig(:logs, :file, :sys)
+      @api_logger = Logger::new filename, 'daily', 7, level: @config.dig(:logs, :file, :api)
+      @wrk_logger = Logger::new filename, 'daily', 7, level: @config.dig(:logs, :file, :wrk)
+    end
+    @log_levels = {
+      sys: Logger::Severity::coerce(@config.dig(:logs, :screen, :sys)),
+      api: Logger::Severity::coerce(@config.dig(:logs, :screen, :api)),
+      wrk: Logger::Severity::coerce(@config.dig(:logs, :screen, :wrk))
+    }
+  end
+
+  def register **opts
+    @table.append(**opts)
+  end
+
+  def update **opts
+    @table.update(**opts)
+  end
+
+  def log severity, message, progname, **opts
+    key = prog_key progname
+    pid = opts[:_sender_pid]
+    console_log severity, message, progname, key, pid
+    file_log severity, message, progname, key if @config.dig(:logs, :file, :enable)
+    true
+  end
+
+  private
+
+  def prog_key progname
+    if progname.nil? || progname == ''
+      :sys
+    elsif progname == 'SYS' || progname == 'API'
+      progname.downcase.to_sym
+    else
+      :wrk
+    end
+  end
+
+  def file_log severity, message, progname, prog_key
+    case prog_key
+    when :api
+      @api_logger.log severity, message, progname
+    when :wrk 
+      @wrk_logger.log severity, message, progname
+    else
+      @sys_logger.log severity, message, progname
+    end
+  end
+
+  SEV_ICON = {
+    Logger::Severity::DEBUG => '📓',
+    Logger::Severity::INFO  => '📢',
+    Logger::Severity::WARN  => '🔔',
+    Logger::Severity::ERROR => '🚨',
+    Logger::Severity::FATAL => '❌'
+  }
+
+  def console_log severity, message, progname, prog_key, pid
+    if severity >= @log_levels[prog_key]
+      if prog_key == :wrk
+        @table.update _sender_pid: pid, message: "#{ SEV_ICON[severity] } #{ message }"
+      else
+        @table.summary message: "#{ SEV_ICON[severity] } [#{ progname }] #{ message }"
+      end
+    end
+  end
+
+end

data/lib/inat-get/app/core/console_logger.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+require_relative '../../info'
+
+module INatGet::App; end
+
+class INatGet::App::ConsoleLogger < Logger
+
+  def initialize console, **options
+    @console = console
+    super(nil, **options)
+  end
+
+  def add severity, msg = nil, progname = nil
+    if block_given?
+      msg = yield
+    elsif msg.nil?
+      msg = progname
+      progname = nil
+    end
+    return if msg.nil?
+    @console.log severity, msg, (progname || self.progname)
+  end
+
+end