kafkr 0.018.1 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e7fd62a57849b5096b9cba1a6928ee2786a401084ca29af0bfdfb1fc2cab7c5
-  data.tar.gz: 6ca89348304182eeabb6c4518818ad804d6b1b4c429c52ba82905cbf431bbb12
+  metadata.gz: 562897f55ad72dc74c2d7a50d1a604fe40bfc0629c9fd8fe828acda386ba721c
+  data.tar.gz: 8d8745987c793c5df150f3fb1a586648ec7b8bd519681f9368f4400f304fe016
 SHA512:
-  metadata.gz: a2ec64c8b63a6b57860ad372ca2dc851dffca1955f7ffe0a1958aaa3a636e50f05fd581e5556761355c8515317c16f29b4d78c8d839c7c429976789d2fcfcb61
-  data.tar.gz: f10c003cecfacbcd05376832784430262bcdb26244efe5c345a22bdf30a75ca67b335e48bc1a6b6c72476619ab984c3b4d66a10b54562b5805940ee4e9974b9a
+  metadata.gz: 5c1f5869497af97e702017ff175478cc1c6c4dbf32843385172dea0e6ca1447ca8c054a3f4327a6ceb66df3403918052ef03d9dd66cb5e397f8d32ab1ae72c1d
+  data.tar.gz: ec955aea4857a2b9824e3fabde5870ebc0a4e5c0abeeeec49c3eaff253334ff1dea89fb0bd3abaf1f03d9442e19d7a19a00ff8af59eb4ea4f0abd1dc81300cb6

data/exe/kafkr-consumer

@@ -51,7 +51,7 @@ def start_consumer(port, host, timeout)
 
   $current_consumer = Kafkr::Consumer.new
   $current_consumer.listen do |message|
-    # Processing of the message
+    Kafkr.log "Message consumed: #{message}"# Processing of the message
   end
 end
 

data/exe/kafkr-producer

@@ -1,11 +1,12 @@
 #!/usr/bin/env ruby
+require "kafkr"
 require "readline"
 
 # Parsing command line arguments for host and port
 host = ARGV[0] || "localhost"
 port = ARGV[1] || 4000
 
-kakf "Running on host: #{host} and port: #{port}"
+Kafkr.log "Running on host: #{host} and port: #{port}"
 
 begin
   require "kafkr"

data/handlers/web_handler.rb

@@ -1,6 +1,8 @@
+require "pry"
+
 class WebHandler < Kafkr::Consumer::Handler
   def handle?(message)
-    can_handle? message, "web"
+    message.include?("web")
   end
 
   def handle(message)

data/lib/kafkr/consumer.rb

@@ -77,23 +77,6 @@ module Kafkr
         Kafkr::Producer.send_message({reply: {payload: payload, uuid: to["sync_uid"]}})
       end
 
-      private
-
-      def can_handle?(message, name, ignore: :any)
-        if message.is_a?(Numeric)
-          return true if message == name.to_i
-        elsif ignore == :hash
-          return true if message[:message] && message[:message][:body] && message[:message][:body] == name
-          return true if message[:message] && message[:message][:body] && message[:message][:body].start_with?(name)
-        elsif ignore == :string
-          return true if message.key? name
-        else
-          return true if message.key? name
-          return true if message[:message] && message[:message][:body] && message[:message][:body] == name
-          return true if message[:message] && message[:message][:body] && message[:message][:body].start_with?(name)
-        end
-        false
-      end
     end
 
     def initialize(host = Consumer.configuration.host, port = Consumer.configuration.port)
@@ -113,40 +96,6 @@ module Kafkr
       /^[A-Z]\w*$/.match?(name)
     end
 
-    def print_handler_class(name)
-      return if name.is_a?(Numeric)
-      name = name.keys.first if name.is_a?(Hash)
-      handler_name = "#{name.downcase}_handler"
-
-      if $loaded_handlers.key?(handler_name)
-        return
-      end
-
-      if Kafkr::Consumer.configuration.suggest_handlers
-        if valid_class_name?(name.capitalize)
-          Kafkr.log "No handler for this message, you could use this one.\n\n"
-
-          handler_class_string = <<~HANDLER_CLASS
-            class #{name.capitalize}Handler < Kafkr::Consumer::Handler
-              def handle?(message)
-                can_handle? message, '#{name}'
-              end
-
-              def handle(message)
-                Kafkr.log message
-              end
-            end
-
-            # Save the file to ./handlers/#{name}_handler.rb
-          HANDLER_CLASS
-
-          Kafkr.log handler_class_string
-        end
-      end
-    end
-
-    require "timeout"
-
     def listen_for(message, send_message)
       attempt = 0
       begin
@@ -202,7 +151,8 @@ module Kafkr
     private
 
     def dispatch_to_handlers(message)
-      message_hash = message.is_a?(String) ? {message: {body: message}} : message
+      
+      message_hash = JSON.parse(message)
 
       self.class.handlers.each do |handler|
         if handler.handle?(message_hash)
@@ -210,8 +160,6 @@ module Kafkr
         end
       end
 
-      print_handler_class(message)
-
       yield message_hash if block_given?
     end
   end

data/lib/kafkr/log.rb

@@ -1,5 +1,7 @@
 require "socket"
 require "rubygems"
+require "kafkr"
+
 
 module Kafkr
   class Log
@@ -50,13 +52,13 @@ module Kafkr
                 decryptor = Kafkr::Encryptor.new
                 message = decryptor.decrypt(encrypted_message.chomp) # Decrypt the message here
                 uuid, message_content = extract_uuid(message)
-                @broker.broadcast(message_content)
+                @broker.broadcast(JSON.dump(message_content))
               end
             rescue Errno::ECONNRESET
               client.close
             end 
           rescue StandardError => exception
-            #TODO we need to find the place for a global exception handler
+            Kafkr.log "Error: #{exception.message}"
           end
         end
       end

data/lib/kafkr/message_broker.rb

@@ -16,7 +16,7 @@ module Kafkr
       encrypted_message = Kafkr::Encryptor.new.encrypt(message) 
       @subscribers.each do |subscriber|
         if !subscriber.closed?
-          subscriber.Kafkr.log(encrypted_message)
+          subscriber.puts(encrypted_message)
           @last_sent[subscriber] = encrypted_message
         end
       rescue Errno::EPIPE

data/lib/kafkr/producer.rb

@@ -17,7 +17,7 @@ module Kafkr
       @configuration.queue_file = MESSAGE_QUEUE
       @configuration.message_queue = []
       load_queue_from_file
-      @configuration.is_json = false
+      @configuration.is_json = true
       @configuration
     end
 
@@ -27,28 +27,6 @@ module Kafkr
       logger.error("Configuration error: #{e.message}")
     end
 
-    def self.structured_data_to_hash(input:, sync_uid:)
-      unless /\A\w+\s*(=>|<=>)\s*((\w+:\s*['"]?[^'",]*['"]?,\s*)*(\w+:\s*['"]?[^'",]*['"]?)\s*)\z/.match?(input)
-        return input
-      end
-
-      if input.include?("<=>")
-        type, key_values_str = input.split("<=>").map(&:strip)
-        key_values = key_values_str.scan(/(\w+):\s*['"]?([^'",]*)['"]?/)
-        hash_body = key_values.to_h do |key, value|
-          [key.to_sym, value.strip.gsub(/\A['"]|['"]\z/, "")]
-        end
-        {type.to_sym => hash_body, :sync => true, :sync_uid => sync_uid}
-      else
-        type, key_values_str = input.split("=>").map(&:strip)
-        key_values = key_values_str.scan(/(\w+):\s*['"]?([^'",]*)['"]?/)
-        hash_body = key_values.to_h do |key, value|
-          [key.to_sym, value.strip.gsub(/\A['"]|['"]\z/, "")]
-        end
-        {type.to_sym => hash_body}
-      end
-    end
-
     def self.send_message(message)
       return if message.nil? || message.empty?
 
@@ -59,15 +37,6 @@ module Kafkr
         json_message = JSON.parse(message)
         json_message["uuid"] = uuid
         message_with_uuid = JSON.dump(json_message)
-      else
-        if message.is_a? String
-          message = structured_data_to_hash(input: message, sync_uid: uuid)
-          message_with_uuid = "#{uuid}: #{message}"
-        end
-
-        if message.is_a?(Hash)
-          message_with_uuid = "#{uuid}: #{JSON.generate(message)}"
-        end
       end
 
       encrypted_message_with_uuid = Kafkr::Encryptor.new.encrypt(message_with_uuid)
@@ -75,7 +44,7 @@ module Kafkr
       begin
         socket = TCPSocket.new(@configuration.host, @configuration.port)
         send_queued_messages(socket)
-        socket.Kafkr.log(encrypted_message_with_uuid)
+        socket.puts (encrypted_message_with_uuid)
       rescue Errno::ECONNREFUSED
         Kafkr.log "Connection refused. Queuing message: #{encrypted_message_with_uuid}"
         @configuration.message_queue.push(encrypted_message_with_uuid)
@@ -106,14 +75,14 @@ module Kafkr
     def self.send_queued_messages(socket)
       until @configuration.message_queue.empty?
         queued_message = @configuration.message_queue.shift
-        socket.Kafkr.log(queued_message)
+        socket.puts(queued_message)
       end
     end
 
     def self.save_queue_to_file
       @@file_mutex.synchronize do
         File.open(@configuration.queue_file, "w") do |file|
-          file.Kafkr.log(@configuration.message_queue)
+          file.puts(@configuration.message_queue)
         end
       end
     end
@@ -126,8 +95,5 @@ module Kafkr
       end
     end
 
-    def self.logger
-      @logger ||= Logger.new(STDOUT)
-    end
   end
 end

data/lib/kafkr/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kafkr
-  VERSION = "0.018.1"
+  VERSION = "0.22.0"
 end

data/lib/kafkr.rb

@@ -1,11 +1,11 @@
-# frozen_string_literal: true
-
+require "pry"
 require "logger"
 require "openssl"
 require "securerandom"
 require "ostruct"
 require "gibberish"
 
+# Assuming the relative paths are correct and these files exist.
 require_relative "kafkr/encryptor"
 require_relative "kafkr/message_broker"
 require_relative "kafkr/log"
@@ -14,73 +14,37 @@ require_relative "kafkr/producer"
 require_relative "kafkr/version"
 
 module Kafkr
+  LOG_FILE_PATH = "/var/log/kafkr.log" # Default log file path
+
   class << self
-    attr_accessor :current_environment
+    attr_writer :log_file_path
+
     def logger
       @logger ||= configure_logger
     end
 
-    def configure_logger(output = default_output)
-      begin
-        @logger = ::Logger.new(output)
-      rescue Errno::EACCES, Errno::ENOENT => e
-        @logger = ::Logger.new(STDOUT)
-        @logger.error("Could not open log file: #{e.message}")
-      end
-      set_logger_level
-      @logger
-    end
-
-    def default_output
-      case current_environment
-      when "production"
-        "/var/log/kafkr.log"
-      else
-        STDOUT
-      end
-    end
-
-    def set_logger_level
-      @logger.level = case current_environment
-      when "development"
-        ::Logger::DEBUG
-      when "staging"
-        ::Logger::INFO
-      when "production"
-        ::Logger::WARN
-      else
-        ::Logger::DEBUG
-      end
-    end
-
-    def current_environment
-      @current_environment ||= ENV["KAFKR_ENV"] || "development"
-    end
-
-    def development?
-      current_environment == "development"
-    end
-
-    def test?
-      current_environment == "test"
-    end
-
-    def staging?
-      current_environment == "staging"
+    def log_file_path
+      @log_file_path || LOG_FILE_PATH
     end
 
-    def production?
-      current_environment == "production"
+    def configure_logger
+      logger = ::Logger.new(log_file_path)
+      logger.level = ::Logger::DEBUG
+      logger
+    rescue Errno::EACCES, Errno::ENOENT => e
+      # Fallback to STDOUT only if file creation fails, can be removed to strictly enforce file logging
+      logger = ::Logger.new(STDOUT)
+      logger.error("Could not open log file: #{e.message}")
+      logger
     end
 
     def write(message, unique_id = nil)
-      begin
-        logger.info(message)
-      rescue IOError => e
-        @logger.error("Failed to write log: #{e.message}")
-      end
+      logger.info(message)
+    rescue IOError => e
+      logger.error("Failed to write log: #{e.message}")
     end
 
+    # Maintaining existing method aliases
     alias_method :log, :write
     alias_method :output, :write
     alias_method :info, :write
@@ -99,4 +63,4 @@ module Kafkr
   rescue => e
     logger.error("Configuration error: #{e.message}")
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kafkr
 version: !ruby/object:Gem::Version
-  version: 0.018.1
+  version: 0.22.0
 platform: ruby
 authors:
 - Delaney Kuldvee Burke
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-10 00:00:00.000000000 Z
+date: 2024-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gibberish