etna 0.1.35 → 0.1.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf1f86e15c74113a4591afd3d8a43064b6ed3b448bdfad3739baa27061df7913
-  data.tar.gz: ed543c8775c89679b4755ca3119899639fc125df2d7e65c3515998f06ae45de8
+  metadata.gz: c21212f38bbad3cf757eb84a9e453428c9d0b6f195fd34eb81f98aeff2746490
+  data.tar.gz: 3581821244c087cbbfbac162f9a5c61911e06ab64923c603a144d36ca3bedff0
 SHA512:
-  metadata.gz: 8523211434696c74c03ca5319a089c74dba9bc3c3cc086f723dcadd1789c91f2e6c7fe43701cd3ac467460bc5a8ee1f4c82c032a5d0ac16e666a565212fba209
-  data.tar.gz: 60e3338c3021ea2e1a54dcfb7f2a15c9ffce71aed5a12db7739992649cfd9518f19edc49262a0095ba09c8783e0ef499bcb3015aebca0d2b7751e7096cbf88eb
+  metadata.gz: 3289530a2e874d2b79b0da66ea787e30b335b7a60626e4b67f1be9919067d4b79752db4e878ca8851dbce6c68a1e59a573bcbc60314bb7a35268cd37cc2eeaae
+  data.tar.gz: 2758348f253992e08fbf589d2b5444844becf69e179872c630804a7e8885568189168edd056c56beabe4ed5dc3e0905f46c51595896bd7bdd1255fbe4ece71ec

data/lib/etna.rb

@@ -21,6 +21,7 @@ require_relative './etna/environment_scoped'
 require_relative './etna/filesystem'
 require_relative './etna/formatting'
 require_relative './etna/cwl'
+require_relative './etna/metrics'
 
 class EtnaApp
   include Etna::Application

data/lib/etna/application.rb

@@ -8,6 +8,7 @@ require_relative './command'
 require_relative './generate_autocompletion_script'
 require 'singleton'
 require 'rollbar'
+require 'fileutils'
 
 module Etna::Application
   def self.included(other)
@@ -31,6 +32,12 @@ module Etna::Application
     raise "Could not find application instance from #{namespace}, and not subclass of Application found."
   end
 
+  # Used to find the application in development recorded vcr tests.
+  # see spec/vcr.rb
+  def dev_route
+    "#{self.class.name.split('::').first.downcase}.development.local"
+  end
+
   def self.register(app)
     @instance = app
   end
@@ -53,6 +60,72 @@ module Etna::Application
     end
   end
 
+  # This will cause metrics to persist to a file.
+  # NOTE -- /tmp/metrics.bin should be a persistent mount when using this.
+  # You will still need to export metrics in the text format for the node_exporter on the host machine to
+  # export them to prometheus.  Ensure that the /tmp/metrics.bin is on a named volume or a bind mount, either is fine.
+  def enable_job_metrics!
+    require 'prometheus'
+    Prometheus::Client.config.data_store = Prometheus::Client::DataStores::DirectFileStore.new({
+      dir: "/tmp/metrics.bin"
+    })
+  end
+
+  def setup_yabeda
+    application = self.id
+    Yabeda.configure do
+      default_tag :application, application
+
+      group :etna do
+        histogram :response_time do
+          comment "Time spent by a controller returning a response"
+          unit :seconds
+          tags [:controller, :action, :user_hash, :project_name]
+          buckets [0.01, 0.1, 0.3, 0.5, 1, 5]
+        end
+
+        counter :visits do
+          comment "Counts visits to the controller"
+          tags [:controller, :action, :user_hash, :project_name]
+        end
+
+        counter :rollbar_errors do
+          comment "Counts errors detected by and sent to rollbar"
+        end
+
+        gauge :last_command_completion do
+          comment "Unix time of last time command was completed"
+          tags [:command, :status, :application]
+        end
+
+        histogram :command_runtime do
+          comment "Time spent processing a given command"
+          tags [:command, :status, :application]
+          unit :seconds
+          buckets [0.1, 1, 5, 60, 300, 1500]
+        end
+      end
+    end
+
+    Yabeda.configure!
+  end
+
+  # Writes all metrics currently gathered to a text format prometheus file.  If /tmp/metrics.prom is bind mounted
+  # to the host directed bound to the node_exporter's file exporter directory, these will be exported to
+  # prometheus.  Combine this enable_job_metrics! for maximum effect.
+  def write_job_metrics(name)
+    node_metrics_dir = "/tmp/metrics.prom"
+    ::FileUtils.mkdir_p(node_metrics_dir)
+
+    tmp_file = ::File.join(node_metrics_dir, "#{name}.prom.$$")
+    ::File.open(tmp_file, "w") do |f|
+      f.write(Prometheus::Client::Formats::Text.marshal(Prometheus::Client.registry))
+    end
+
+    require 'fileutils'
+    ::FileUtils.mv(tmp_file, ::File.join(node_metrics_dir, "#{name}.prom"))
+  end
+
   def setup_logger
     @logger = Etna::Logger.new(
       # The name of the log_file, required.
@@ -102,17 +175,32 @@ module Etna::Application
   end
 
   def run_command(config, *args, &block)
+    application = self.id
+    status = 'success'
+    start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     cmd, cmd_args, cmd_kwds = find_command(*args)
-    cmd.setup(config)
 
-    if block_given?
-      return unless yield [cmd, cmd_args]
-    end
+    begin
+      cmd.setup(config)
+      if block_given?
+        return unless yield [cmd, cmd_args]
+      end
 
-    cmd.execute(*cmd.fill_in_missing_params(cmd_args), **cmd_kwds)
-  rescue => e
-    Rollbar.error(e)
-    raise
+      cmd.execute(*cmd.fill_in_missing_params(cmd_args), **cmd_kwds)
+    rescue => e
+      Rollbar.error(e)
+      status = 'failed'
+      raise
+    ensure
+      if Yabeda.configured?
+        tags = { command: cmd.class.name, status: status, application: application }
+        dur = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+
+        Yabeda.etna.last_command_completion.set(tags, Time.now.to_i)
+        Yabeda.etna.command_runtime.measure(tags, dur)
+        write_job_metrics("run_command")
+      end
+    end
   end
 end
 

data/lib/etna/auth.rb

@@ -86,7 +86,7 @@ module Etna
         host: application.config(:janus)[:host]
       )
 
-      response = janus_client.validate_task_token()
+      response = janus_client.validate_task_token
 
       return false unless response.code == '200'
 

data/lib/etna/client.rb

@@ -173,7 +173,7 @@ module Etna
         verify_mode = @ignore_ssl ?
           OpenSSL::SSL::VERIFY_NONE :
           OpenSSL::SSL::VERIFY_PEER
-        Net::HTTP.start(uri.host, uri.port, use_ssl: true, verify_mode: verify_mode) do |http|
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true, verify_mode: verify_mode, read_timeout: 300) do |http|
           http.request(data) do |response|
             status_check!(response)
             yield response
@@ -183,7 +183,7 @@ module Etna
         verify_mode = @ignore_ssl ?
           OpenSSL::SSL::VERIFY_NONE :
           OpenSSL::SSL::VERIFY_PEER
-        Net::HTTP.start(uri.host, uri.port, use_ssl: true, verify_mode: verify_mode) do |http|
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true, verify_mode: verify_mode, read_timeout: 300) do |http|
           response = http.request(data)
           status_check!(response)
           return response

data/lib/etna/clients/base_client.rb

@@ -29,7 +29,8 @@ module Etna
       def token_will_expire?(offset=3000)
         # offset in seconds
         # Will the user's token expire in the given amount of time?
-        epoch_seconds = JSON.parse(Base64.urlsafe_decode64(token.split('.')[1]))["exp"]
+        payload = JSON.parse(Base64.urlsafe_decode64(token.split('.')[1]))
+        epoch_seconds = payload["exp"]
         expiration = DateTime.strptime(epoch_seconds.to_s, "%s")
         expiration <= DateTime.now.new_offset + offset
       end

data/lib/etna/clients/janus/client.rb

@@ -58,20 +58,19 @@ module Etna
         TokenResponse.new(token)
       end
 
-      def validate_task_token(validate_task_token_request = ValidateTaskTokenRequest.new)
-        token = nil
-        @etna_client.post('/api/tokens/task/validate', validate_task_token_request)
+      def validate_task_token
+        @etna_client.post('/api/tokens/validate_task')
       end
 
       def get_nonce
         @etna_client.get('/api/tokens/nonce').body
       end
 
-      def generate_token(token_type, signed_nonce: nil, project_name: nil)
+      def generate_token(token_type, signed_nonce: nil, project_name: nil, read_only: false)
         response = @etna_client.with_headers(
           'Authorization' => signed_nonce ? "Signed-Nonce #{signed_nonce}" : nil
         ) do
-          post('/api/tokens/generate', token_type: token_type, project_name: project_name)
+          post('/api/tokens/generate', token_type: token_type, project_name: project_name, read_only: read_only)
         end
 
         response.body

data/lib/etna/clients/metis/client.rb

@@ -228,14 +228,44 @@ module Etna
         end
 
         folder_contents.files.all.each do |file|
-          rename_file(Etna::Clients::Metis::RenameFileRequest.new(
-            bucket_name: source_bucket,
+          # If file exists in destination, delete the older file.
+          list_dest_folder_request = Etna::Clients::Metis::ListFolderRequest.new(
+            bucket_name: dest_bucket,
             project_name: project_name,
-            file_path: file.file_path,
-            new_bucket_name: dest_bucket,
-            new_file_path: file.file_path,
-            create_parent: true)
+            folder_path: ::File.dirname(file.file_path)
           )
+
+          dest_file = list_folder(list_dest_folder_request).files.all.find { |f| f.file_name == file.file_name }
+
+          should_rename = true
+          if (dest_file && file.updated_at <= dest_file.updated_at)
+            # Delete source file if it's out of date
+            delete_file(Etna::Clients::Metis::DeleteFileRequest.new(
+              bucket_name: source_bucket,
+              project_name: project_name,
+              file_path: file.file_path,
+            ))
+
+            should_rename = false
+          elsif (dest_file && file.updated_at > dest_file.updated_at)
+            # Delete dest file if it's out of date
+            delete_file(Etna::Clients::Metis::DeleteFileRequest.new(
+              bucket_name: dest_bucket,
+              project_name: project_name,
+              file_path: dest_file.file_path,
+            ))
+          end
+
+          if should_rename
+            rename_file(Etna::Clients::Metis::RenameFileRequest.new(
+              bucket_name: source_bucket,
+              project_name: project_name,
+              file_path: file.file_path,
+              new_bucket_name: dest_bucket,
+              new_file_path: file.file_path,
+              create_parent: true)
+            )
+          end
         end
 
         # Now delete the source folder

data/lib/etna/clients/metis/workflows.rb

@@ -1,3 +1,4 @@
-require_relative './workflows/metis_download_workflow'
-require_relative './workflows/metis_upload_workflow'
-require_relative './workflows/sync_metis_data_workflow'
+require_relative "./workflows/metis_download_workflow"
+require_relative "./workflows/metis_upload_workflow"
+require_relative "./workflows/sync_metis_data_workflow"
+require_relative "./workflows/ingest_metis_data_workflow"

data/lib/etna/clients/metis/workflows/ingest_metis_data_workflow.rb

@@ -0,0 +1,31 @@
+require "ostruct"
+require "fileutils"
+require "tempfile"
+
+module Etna
+  module Clients
+    class Metis
+      class IngestMetisDataWorkflow < Struct.new(:metis_filesystem, :ingest_filesystem, :logger, keyword_init: true)
+        # Since we are doing manual triage of files,
+        #   do not automatically copy directory trees.
+        # srcs must be a list of full paths to files.
+        def copy_files(srcs)
+          srcs.each do |src|
+            next unless ingest_filesystem.exist?(src)
+
+            logger&.info("Copying file #{src} (#{Etna::Formatting.as_size(ingest_filesystem.stat(src).size)})")
+
+            # For ingestion triage, just copy over the exact path + filename.
+            copy_file(dest: src, src: src)
+          end
+        end
+
+        def copy_file(dest:, src:)
+          ingest_filesystem.with_readable(src, "r") do |file|
+            metis_filesystem.do_streaming_upload(file, dest, file.size)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etna/clients/metis/workflows/metis_upload_workflow.rb

@@ -30,7 +30,7 @@ module Etna
               project_name: project_name,
               bucket_name: bucket_name,
               folder_path: dir,
-          ))
+          )) unless dir == "."
 
           authorize_response = metis_client.authorize_upload(AuthorizeUploadRequest.new(
               project_name: project_name,

data/lib/etna/controller.rb

@@ -19,25 +19,30 @@ module Etna
       @logger.warn(request_msg(line))
     end
 
+    def handle_error(e)
+      case e
+      when Etna::Error
+        Rollbar.error(e)
+        @logger.error(request_msg("Exiting with #{e.status}, #{e.message}"))
+        return failure(e.status, error: e.message)
+      else
+        Rollbar.error(e)
+        @logger.error(request_msg('Caught unspecified error'))
+        @logger.error(request_msg(e.message))
+        e.backtrace.each do |trace|
+          @logger.error(request_msg(trace))
+        end
+        return failure(500, error: 'Server error.')
+      end
+    end
+
     def response(&block)
       return instance_eval(&block) if block_given?
-
       return send(@action) if @action
 
-
       [501, {}, ['This controller is not implemented.']]
-    rescue Etna::Error => e
-      Rollbar.error(e)
-      @logger.error(request_msg("Exiting with #{e.status}, #{e.message}"))
-      return failure(e.status, error: e.message)
     rescue Exception => e
-      Rollbar.error(e)
-      @logger.error(request_msg('Caught unspecified error'))
-      @logger.error(request_msg(e.message))
-      e.backtrace.each do |trace|
-        @logger.error(request_msg(trace))
-      end
-      return failure(500, error: 'Server error.')
+      handle_error(e)
     end
 
     def require_params(*params)

data/lib/etna/directed_graph.rb

@@ -52,7 +52,12 @@ class DirectedGraph
             result[grandparent] << child_node if result.include?(grandparent)
           end
 
-          result[child_node] = []
+          # Depending on the graph shape, diamonds could lead to
+          #   resetting of previously calculated dependencies.
+          # Here we avoid resetting existing entries in `result`
+          #   and instead concatenate them if they already exist.
+          result[child_node] = [] unless result.include?(child_node)
+          result[n].concat(result[child_node]) if result.include?(child_node) && result.include?(n)
         end
       end
 

data/lib/etna/filesystem.rb

@@ -3,6 +3,8 @@ require 'fileutils'
 require 'open3'
 require 'securerandom'
 require 'concurrent-ruby'
+require 'net/sftp'
+require 'net/ssh'
 
 module Etna
   # A class that encapsulates opening / reading file system entries that abstracts normal file access in order
@@ -50,6 +52,11 @@ module Etna
       ::FileUtils.mv(src, dest)
     end
 
+    def stat(src)
+      raise "stat not supported by #{self.class.name}" unless self.class == Filesystem
+      ::File.stat(src)
+    end
+
     class EmptyIO < StringIO
       def write(*args)
         # Do nothing -- always leave empty
@@ -369,7 +376,59 @@ module Etna
       end
     end
 
+    class SftpFilesystem < Filesystem
+      def initialize(host:, username:, password: nil, port: 22, **args)
+        @username = username
+        @password = password
+        @host = host
+        @port = port
+      end
+
+      def ssh
+        @ssh ||= Net::SSH.start(@host, @username, password: @password)
+      end
+
+      def sftp
+        @sftp ||= begin
+          conn = Net::SFTP::Session.new(ssh)
+          conn.loop { conn.opening? }
+
+          conn
+        end
+      end
+
+      def with_readable(src, opts = 'r', &block)
+        sftp.file.open(src, opts, &block)
+      end
+
+      def ls(dir)
+        sftp.dir.entries(dir)
+      end
+
+      def exist?(src)
+        begin
+          sftp.file.open(src)
+        rescue Net::SFTP::StatusException
+          return false
+        end
+        return true
+      end
+
+      def stat(src)
+        sftp.file.open(src).stat
+      end
+    end
+
     class Mock < Filesystem
+      class MockStat
+        def initialize
+        end
+
+        def size
+          0
+        end
+      end
+
       def initialize(&new_io)
         @files = {}
         @dirs = {}
@@ -438,6 +497,10 @@ module Etna
       def exist?(src)
         @files.include?(src) || @dirs.include?(src)
       end
+
+      def stat(src)
+        @files[src].respond_to?(:stat) ? @files[src].stat : MockStat.new
+      end
     end
   end
 end

data/lib/etna/logger.rb

@@ -40,6 +40,10 @@ module Etna
         error(trace)
       end
 
+      if defined? Yabeda
+        Yabeda.etna.rollbar_errors.increment({}, 1) rescue nil
+      end
+
       Rollbar.error(e)
     end
 

data/lib/etna/metrics.rb

@@ -0,0 +1,26 @@
+
+module Etna
+  class MetricsExporter
+    def initialize(app, path: '/metrics')
+      @app = app
+      @path = path
+    end
+
+    def exporter
+      @exporter ||= begin
+        exporter = Yabeda::Prometheus::Exporter.new(@app, path: @path)
+        Rack::Auth::Basic.new(exporter) do |user, pw|
+          user == 'prometheus' && pw == ENV['METRICS_PW']
+        end
+      end
+    end
+
+    def call(env)
+      if env['PATH_INFO'] == @path
+        exporter.call(env)
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/etna/route.rb

@@ -1,3 +1,6 @@
+require 'digest'
+require 'date'
+
 module Etna
   class Route
     attr_reader :name
@@ -58,6 +61,63 @@ module Etna
     end
 
     def call(app, request)
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      try_yabeda(request)  do |tags|
+        Yabeda.etna.visits.increment(tags)
+      end
+
+      begin
+        process_call(app, request)
+      ensure
+        try_yabeda(request) do |tags|
+          dur = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+          Yabeda.etna.response_time.measure(tags, dur)
+        end
+      end
+    end
+
+    def hash_user_email(email)
+      secret = Etna::Application.instance.config(:user_hash_secret) || 'notsosecret'
+      digest = email + secret + Date.today.to_s
+
+      if @name
+        digest += @name.to_s
+      else
+        digest += @route.to_s
+      end
+
+      Digest::MD5.hexdigest(digest)
+    end
+
+    def try_yabeda(request, &block)
+      if @action
+        controller, action = @action.split('#')
+      elsif @name
+        controller = "none"
+        action = @name
+      else
+        controller = "none"
+        action = @route
+      end
+
+      params = request.env['rack.request.params']
+      user = request.env['etna.user']
+      user_hash = user ? hash_user_email(user.email) : 'unknown'
+      project_name = "unknown"
+
+      if params && (params.include?(:project_name) || params.include?('project_name'))
+        project_name = params[:project_name] || params['project_name']
+      end
+
+      begin
+        block.call({ controller: controller, action: action, user_hash: user_hash, project_name: project_name })
+      rescue => e
+        raise e unless Etna::Application.instance.environment == :production
+      end
+    end
+
+    def process_call(app, request)
       update_params(request)
 
       unless authorized?(request)
@@ -148,7 +208,10 @@ module Etna
       params = request.env['rack.request.params']
 
       @auth[:user].all? do |constraint, param_name|
-        user.respond_to?(constraint) && user.send(constraint, params[param_name])
+        user.respond_to?(constraint) && (
+          param_name.is_a?(Symbol) ?
+            user.send(constraint, params[param_name]) :
+            user.send(constraint, param_name))
       end
     end
 

data/lib/etna/server.rb

@@ -74,6 +74,11 @@ module Etna
     def initialize
       # Setup logging.
       application.setup_logger
+
+      # This needs to be required before yabeda invocation, but cannot belong at the top of any module since clients
+      # do not install yabeda.
+      require 'yabeda'
+      application.setup_yabeda
     end
 
     private

data/lib/etna/spec/vcr.rb

@@ -4,13 +4,32 @@ require 'openssl'
 require 'digest/sha2'
 require 'base64'
 
-def setup_base_vcr(spec_helper_dir)
+def setup_base_vcr(spec_helper_dir, server: nil, application: nil)
   VCR.configure do |c|
     c.hook_into :webmock
     c.cassette_serializers
     c.cassette_library_dir = ::File.join(spec_helper_dir, 'fixtures', 'cassettes')
     c.allow_http_connections_when_no_cassette = true
 
+    c.register_request_matcher :verify_uri_route do |request_1, request_2|
+      next true if server.nil? || application.nil?
+
+      route_match = request_1.uri =~ /https:\/\/#{application.dev_route}(.*)/
+      if route_match && route_match[1]
+        def request_1.request_method
+          method.to_s.upcase
+        end
+
+        def request_1.path
+          URI(uri).path
+        end
+
+        !!server.find_route(request_1)
+      else
+        true
+      end
+    end
+
     c.register_request_matcher :try_body do |request_1, request_2|
       if request_1.headers['Content-Type'].first =~ /application\/json/
         if request_2.headers['Content-Type'].first =~ /application\/json/
@@ -39,7 +58,7 @@ def setup_base_vcr(spec_helper_dir)
         else
           ENV['RERECORD'] ? :all : :once
         end,
-        match_requests_on: [:method, :uri, :try_body]
+        match_requests_on: [:method, :uri, :try_body, :verify_uri_route]
     }
 
     # Filter the authorization headers of any request by replacing any occurrence of that request's

data/lib/etna/test_auth.rb

@@ -42,7 +42,6 @@ module Etna
       # We do this to support Metis client tests, we pass in tokens with multiple "."-separated parts, so
       #   have to account for that.
       payload = JSON.parse(Base64.decode64(token.split('.')[1]))
-
       request.env['etna.user'] = Etna::User.new(payload.map{|k,v| [k.to_sym, v]}.to_h, token)
     end
 

data/lib/etna/user.rb

@@ -7,7 +7,7 @@ module Etna
     }
 
     def initialize params, token=nil
-      @name, @email, @encoded_permissions, encoded_flags = params.values_at(:name, :email, :perm, :flags)
+      @name, @email, @encoded_permissions, encoded_flags, @task = params.values_at(:name, :email, :perm, :flags, :task)
 
       @flags = encoded_flags&.split(/;/) || []
       @token = token unless !token
@@ -16,6 +16,10 @@ module Etna
 
     attr_reader :name, :email, :token
 
+    def task?
+      !!@task
+    end
+
     def permissions
       @permissions ||= @encoded_permissions.split(/\;/).map do |roles|
         role, projects = roles.split(/:/)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: etna
 version: !ruby/object:Gem::Version
-  version: 0.1.35
+  version: 0.1.39
 platform: ruby
 authors:
 - Saurabh Asthana
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-26 00:00:00.000000000 Z
+date: 2021-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-sftp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 description: See summary
 email: Saurabh.Asthana@ucsf.edu
 executables:
@@ -144,6 +158,7 @@ files:
 - lib/etna/clients/metis/client.rb
 - lib/etna/clients/metis/models.rb
 - lib/etna/clients/metis/workflows.rb
+- lib/etna/clients/metis/workflows/ingest_metis_data_workflow.rb
 - lib/etna/clients/metis/workflows/metis_download_workflow.rb
 - lib/etna/clients/metis/workflows/metis_upload_workflow.rb
 - lib/etna/clients/metis/workflows/sync_metis_data_workflow.rb
@@ -168,6 +183,7 @@ files:
 - lib/etna/hmac.rb
 - lib/etna/json_serializable_struct.rb
 - lib/etna/logger.rb
+- lib/etna/metrics.rb
 - lib/etna/multipart_serializable_nested_hash.rb
 - lib/etna/parse_body.rb
 - lib/etna/route.rb