metlo 0.0.4-aarch64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ad284f75832168a0dbe1732089e03d0e06a6e56cb85083d2a5bf011f163b1561
+  data.tar.gz: 936cca1361503ca54d4998220892a4e824ef7c5e4f415002aa56fa4be779b1fa
+SHA512:
+  metadata.gz: dc6b15b59502114d68fbe3073becd212ea872d9631eb7dcd28a28f47cf83664956dce9108b949512d7920633294f42abbe673770483aeec038d24e9153e1457a
+  data.tar.gz: 4561db2f634ae5d42b79108e4d2dc8d8bea05b87a5b2bbca310fc452e3977aa288908e0303ce12d91c245e158f799aefb55acfcfb3536b31b1f82d6f8bb854aa

data/.standard.yml

@@ -0,0 +1,2 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in metlo.gemspec
+gemspec
+
+gem "rake", "~> 12.0"

data/README.md

@@ -0,0 +1,19 @@
+# Metlo
+
+The Metlo agent for ruby frameworks able to utilize rack based middleware
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'metlo'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install metlo

data/Rakefile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "standard/rake"
+
+task default: :standard

data/lib/metlo/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Metlo
+  VERSION = "0.0.4"
+end

data/lib/metlo.rb

@@ -0,0 +1,287 @@
+require_relative "metlo/version"
+require "json"
+require_relative "./libmetlo"
+
+module Metlo
+
+    class Metlo
+        
+        @@MAX_RES_ITER_COUNT = 10
+        @@MAX_BODY_LENGTH = 10 * 1024
+        @@LOG_LEVELS = ["trace","debug","info","warn","error"]
+
+        def initialize(app, params = {})
+            @app = app
+            @disable = false
+            @block_fn = method(:metlo_default_block)
+            @get_user = nil
+
+            metlo_url = params[:metlo_url]
+            api_key = params[:api_key]
+            backend_port = params[:backend_port]
+            collector_port = params[:collector_port]
+            encryption_key = params[:encryption_key]
+            log_level = params[:log_level]
+            block_response = params[:block_response]
+            get_user = params[:get_user]
+
+            if not (log_level.nil?) 
+                if not (log_level.is_a? String)
+                    log_level = "info"
+                    @logger = Logger.new($stdout,convert_log_level(log_level))
+                    @logger.warn("log_level is not a string. log_level is expected to be one of trace, debug, info, warn, error.\nDefaulting log level to info.")
+                elsif not (@@LOG_LEVELS.include? log_level)
+                    log_level = "info"
+                    @logger = Logger.new($stdout,convert_log_level(log_level))
+                    @logger.warn("log_level is not one of trace, debug, info, warn, error.\nDefaulting log level to info")
+                end
+            else
+                log_level = "info"
+                @logger = Logger.new($stdout,convert_log_level(log_level))
+            end
+
+            setup_log(@logger)
+
+            # Metlo URL
+            if not (metlo_url.is_a? String)
+                @logger.warn("metlo_url is not a string")
+                @disable = true
+            end
+
+            # Metlo API Key
+            if not (api_key.is_a? String)
+                @logger.warn("api_key is not a string")
+                @disable = true
+            end
+
+            # Backend Port
+            if not (backend_port.nil?)
+                # Value is present
+                if not (backend_port.is_a? Integer)
+                    @logger.warn("backend_port is not an integer")
+                    @disable = true
+                end
+            else
+                # Value missing.
+                if metlo_url.include? "app.metlo.com"
+                    backend_port = 443
+                else
+                    backend_port = 8000
+                end
+            end
+
+            # Collector Port
+            if not (collector_port.nil?)
+                if not (collector_port.is_a? Integer)
+                    @logger.warn("collector_port is not an integer")
+                    @disable = true
+                end 
+            else
+                collector_port = 8081
+            end
+
+            if not (encryption_key.nil?) and not (encryption_key.is_a? String)
+                @logger.warn("Encryption key is expected to be a string.")
+                encryption_key = nil
+            end
+            
+            if not (block_response.nil?)
+                if not defined? block_response == "expression"
+                    @logger.warn("block_response param is expected to be a symbol to a method/function")
+                    @block_fn = method(:metlo_default_block)
+                else
+                    if not(((defined? method(block_response)) == "method") and (method(block_response).arity == 1))
+                        @logger.warn("block_response param is expected to be a method that takes a single param")
+                        @block_fn = method(:metlo_default_block)
+                    else
+                        @block_fn = method(block_response)
+                    end
+                end
+            else
+                @block_fn = method(:metlo_default_block)
+            end
+
+
+            if not (get_user.nil?)
+                if not (defined? get_user == "expression" and defined? method(get_user) == "method" and method(get_user).arity == 1)
+                    @logger.warn("get_user param is expected to be a method that takes a single param env")
+                    @get_user = nil
+                else
+                    @get_user = method(get_user)
+                end
+            end
+
+            if not (@disable)
+                startup(
+                    metlo_url,
+                    api_key,
+                    backend_port,
+                    collector_port,
+                    log_level,
+                    encryption_key
+                )
+            end
+        end
+
+        def call(env)
+            if not (@disable)
+                req = nil
+                meta = nil
+                res = nil
+                begin
+                    req_raw = create_req(env)
+                    req = JSON.generate(req_raw)
+                    meta_raw = create_meta(env)
+                    meta = JSON.generate(meta_raw)
+                rescue StandardError => e
+                    status, headers, response = @app.call(env)
+                    [status, headers, response]
+                else
+                    block = block_trace(req,meta)
+                    if block
+                        status, headers, response = (@block_fn).call env
+                    else
+                        status, headers, response = @app.call(env)
+                    end
+                    res_raw = create_res(status,headers,response)
+                    res = JSON.generate(res_raw)
+
+                    ingest_trace(req,res,meta)
+
+                    [status, headers, response]
+                end
+            else
+                @app.call(env)
+            end
+
+        end
+
+        private
+
+        def create_req(env)
+            input_stream = env["rack.input"]
+            body = input_stream.read(1024*10)
+            input_stream.rewind
+            if body.nil?
+                body = ""
+            end
+
+            user = nil
+
+            if not (@get_user.nil?)
+                user = get_user(env)
+            end
+
+            body = body.to_str.force_encoding("UTF-8")
+            req = {
+                "url"=>{
+                    "host"=>env["SERVER_NAME"],
+                    "path"=>env["PATH_INFO"],
+                    "parameters"=>env["QUERY_STRING"] != nil ? env["QUERY_STRING"].split("&").map{|s|s.split("=")}.map{|a,b| {"name"=>a,"value"=>b}}:[],
+                },
+                "headers"=>env.select{|k,v| k.start_with? "HTTP_"}.map{|k,v| {"name":k[5..-1].gsub("_","-"),"value":v}},
+                "method"=>env["REQUEST_METHOD"],
+                "body"=>body.to_str,
+                "user"=>user
+            }
+            return req
+        end
+        
+        def create_res(status,headers,response)
+            body = ""
+            current_body_fill = ""
+            if defined? response.each
+                body_tmp = response.each
+                if body_tmp.class == Enumerator
+                    count = 0
+                    curr_body_length = 0
+                    loop do
+                        segment = body_tmp.next
+
+                        remaining_length = @@MAX_BODY_LENGTH - curr_body_length
+                        curr_segment = segment[0..remaining_length]
+                        curr_body_length = curr_body_length + curr_segment.length
+                        body += curr_segment
+
+                        # Make sure that we don't keep reading from an input
+                        if count < @@MAX_RES_ITER_COUNT
+                            count = count+1
+                        else
+                            break
+                        end
+
+                    end
+                    body_tmp.rewind
+                end
+            else
+                @logger.debug("Metlo doesn't currently handle streaming responses")
+            end
+
+            # Check response type
+
+            # If enumerable
+            # Give preference to enumerable over stream
+            # Also need to make sure that enumerable is read only once. 
+            # So instead, pass on a new response object that implements the same methods
+            # and when each method is called on that object, intercept that and read it and pass on the information to metlo
+            # defined?(response.each)
+
+            # If streaming
+            # defined?(response.call)
+            # response.call takes in a single argument for stream.
+            # Stream must implement methods: read, write, <<, flush, close, close_read, close_write, closed?
+
+            # If array
+            # defined?(response.to_ary)
+
+            # If path
+            # defined?(response.to_path)
+            return {
+                "status"=>status,
+                "headers"=>headers.map{|k,v| {"name":k,"value":v}},
+                "body"=>body,
+            }
+        end
+
+        def create_meta(env)
+            server = env['rack.hijack'].io.addr
+            client = env['rack.hijack'].io.peeraddr
+            return {
+                "environment": "production",
+                "incoming": true,
+                "source": client[2],
+                "sourcePort": client[1],
+                "destination": server[2],
+                "destinationPort": server[1]
+            }
+        end
+
+        def metlo_default_block(env)
+            return [403,{},["Forbidden"]]
+        end
+
+        def setup_log(logger)
+            logger.formatter = proc do |severity, datetime, _progname, msg|
+                datefmt = datetime.strftime('%Y-%m-%dT%H:%M:%S.%6N')
+                "[timestamp=#{datefmt} level=#{severity.ljust(5)}] Metlo: #{msg}\n"
+              end              
+        end
+
+        def convert_log_level(level)
+            if level == "trace"
+                return Logger::DEBUG
+            elsif level == "debug"
+                return Logger::DEBUG
+            elsif level == "info"
+                return Logger::INFO
+            elsif level == "warn"
+                return Logger::WARN
+            elsif level == "error"
+                return Logger::ERROR
+            else
+                return Logger::INFO
+            end                
+        end
+
+    end
+end

data/metlo.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "lib/metlo/version"
+
+raise "RUBY_TARGET_PLATFORM env var not defined" if ENV["RUBY_TARGET_PLATFORM"].nil?
+
+Gem::Specification.new do |spec|
+  spec.name = "metlo"
+  spec.version = Metlo::VERSION
+  spec.authors = ["Metlo"]
+  spec.description = "The Ruby Agent for Metlo"
+  spec.summary = "The Ruby Agent for Metlo"
+  spec.homepage = "https://www.metlo.com"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://www.github.com/metlo-labs/metlo"
+
+  spec.platform = ENV["RUBY_TARGET_PLATFORM"]
+  
+  spec.files = [
+    ".standard.yml",
+    "Gemfile",
+    "README.md",
+    "Rakefile",
+    "lib/metlo.rb",
+    "lib/libmetlo.so",
+    "lib/metlo/version.rb",
+    "metlo.gemspec",
+    "sig/metlo.rbs",
+  ]
+  spec.require_paths = ["lib"]
+
+end

data/sig/metlo.rbs

@@ -0,0 +1,4 @@
+module Metlo
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: metlo
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: aarch64-linux
+authors:
+- Metlo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-07-28 00:00:00.000000000 Z
+dependencies: []
+description: The Ruby Agent for Metlo
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/libmetlo.so
+- lib/metlo.rb
+- lib/metlo/version.rb
+- metlo.gemspec
+- sig/metlo.rbs
+homepage: https://www.metlo.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://www.metlo.com
+  source_code_uri: https://www.github.com/metlo-labs/metlo
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: The Ruby Agent for Metlo
+test_files: []