solidstats 1.0.0 → 2.0.0

data/app/services/solidstats/gem_metadata/fetcher_service.rb

@@ -0,0 +1,136 @@
+require "net/http"
+
+module Solidstats
+  module GemMetadata
+    class FetcherService
+      GemMeta = Struct.new(:name, :version, :current_version, :released, :info, :runtime, keyword_init: true)
+
+      def self.call(gem_names = nil, force_refresh = false)
+        new.call(gem_names, force_refresh)
+      end
+
+      def call(gem_names = nil, force_refresh = false)
+        gem_names = get_gem_names(gem_names)
+        fetch_metadata(gem_names, force_refresh)
+      end
+
+      private
+
+      def get_gem_names(gem_names)
+        return gem_names if gem_names.present?
+
+        gemfile_lock = Rails.root.join("Gemfile.lock")
+        return [] unless File.exist?(gemfile_lock)
+
+        lockfile = File.read(gemfile_lock)
+        parser = Bundler::LockfileParser.new(lockfile)
+        parser.specs.map(&:name)
+      end
+
+      def get_current_versions
+        gemfile_lock = Rails.root.join("Gemfile.lock")
+        return {} unless File.exist?(gemfile_lock)
+
+        lockfile = File.read(gemfile_lock)
+        parser = Bundler::LockfileParser.new(lockfile)
+
+        parser.specs.each_with_object({}) do |spec, versions|
+          versions[spec.name] = spec.version.to_s
+        end
+      end
+
+      def fetch_metadata(gem_names, force_refresh)
+        current_versions = get_current_versions
+
+        gem_names.map do |name|
+          fetch_gem_data(name, current_versions[name], force_refresh)
+        end
+      end
+
+      def fetch_gem_data(name, current_version, force_refresh)
+        cached_data = fetch_from_cache(name) unless force_refresh
+
+        if cached_data
+          # Update current version if it changed since caching
+          if current_version && cached_data.current_version != current_version
+            cached_data.current_version = current_version
+            cache_data(name, cached_data)
+          end
+          return cached_data
+        end
+
+        begin
+          data = fetch_from_api(name)
+          meta = GemMeta.new(
+            name: data["name"],
+            version: data["version"],
+            current_version: current_version,
+            released: data["version_created_at"] ? Time.parse(data["version_created_at"]) : nil,
+            info: data["info"],
+            runtime: data["dependencies"] && data["dependencies"]["runtime"] || []
+          )
+          cache_data(name, meta)
+          meta
+        rescue => e
+          Rails.logger.error("Failed to fetch gem metadata for #{name}: #{e.message}")
+          GemMeta.new(name: name, current_version: current_version, info: "(API unavailable)")
+        end
+      end
+
+      def fetch_from_api(name)
+        uri = URI.parse("https://rubygems.org/api/v1/gems/#{name}.json")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.open_timeout = 5
+        http.read_timeout = 5
+
+        response = http.get(uri.request_uri)
+
+        if response.code == "200"
+          JSON.parse(response.body)
+        else
+          raise "API request failed with status #{response.code}"
+        end
+      end
+
+      def fetch_from_cache(name)
+        cache_file = cache_path(name)
+        return nil unless File.exist?(cache_file)
+
+        data = JSON.parse(File.read(cache_file))
+        cache_time = File.mtime(cache_file)
+
+        # Return nil if cache is older than 24 hours
+        return nil if Time.now - cache_time > 24.hours
+
+        GemMeta.new(
+          name: data["name"],
+          version: data["version"],
+          current_version: data["current_version"],
+          released: data["released"] ? Time.parse(data["released"]) : nil,
+          info: data["info"],
+          runtime: data["runtime"] || []
+        )
+      end
+
+      def cache_data(name, meta)
+        FileUtils.mkdir_p(File.dirname(cache_path(name)))
+
+        data = {
+          "name" => meta.name,
+          "version" => meta.version,
+          "current_version" => meta.current_version,
+          "released" => meta.released&.iso8601,
+          "info" => meta.info,
+          "runtime" => meta.runtime
+        }
+
+        File.write(cache_path(name), data.to_json)
+      end
+
+      def cache_path(name)
+        Rails.root.join("tmp", "cache", "gem_metadata", "#{name}.json")
+      end
+    end
+  end
+end

data/app/services/solidstats/log_size_monitor_service.rb

@@ -0,0 +1,94 @@
+module Solidstats
+  class LogSizeMonitorService
+    WARNING_THRESHOLD = 25  # In megabytes
+    DANGER_THRESHOLD = 50   # In megabytes
+
+    def collect_data
+      log_files = scan_log_directory
+      total_size_bytes = log_files.sum { |file| file[:size_bytes] }
+
+      # Create aggregated data
+      {
+        log_dir_path: log_directory,
+        total_size_bytes: total_size_bytes,
+        total_size_mb: bytes_to_mb(total_size_bytes),
+        status: calculate_status(total_size_bytes),
+        logs_count: log_files.size,
+        log_files: log_files,
+        created_at: Time.now.iso8601
+      }
+    end
+
+    def truncate_log(filename = nil)
+      begin
+        if filename.present?
+          # Truncate specific log file
+          # Ensure filename has .log extension
+          filename = "#{filename}.log" unless filename.end_with?(".log")
+
+          file_path = File.join(log_directory, filename)
+          if File.exist?(file_path)
+            File.open(file_path, "w") { |f| f.truncate(0) }
+            { success: true, message: "Log file '#{filename}' truncated successfully" }
+          else
+            { success: false, message: "Log file '#{filename}' not found" }
+          end
+        else
+          # Truncate all log files
+          scan_log_directory.each do |log_file|
+            File.open(log_file[:path], "w") { |f| f.truncate(0) }
+          end
+          { success: true, message: "All log files truncated successfully" }
+        end
+      rescue => e
+        { success: false, message: "Failed to truncate log file: #{e.message}" }
+      end
+    end
+
+    private
+
+    def log_directory
+      Rails.root.join("log").to_s
+    end
+
+    def scan_log_directory
+      log_files = []
+
+      # Get all files in the log directory
+      Dir.glob(File.join(log_directory, "*.log")).each do |file_path|
+        if File.file?(file_path)
+          size_bytes = File.size(file_path)
+          filename = File.basename(file_path)
+
+          log_files << {
+            filename: filename,
+            path: file_path,
+            size_bytes: size_bytes,
+            size_mb: bytes_to_mb(size_bytes),
+            status: calculate_status(size_bytes),
+            last_modified: File.mtime(file_path)
+          }
+        end
+      end
+
+      # Sort by size (largest first)
+      log_files.sort_by { |file| -file[:size_bytes] }
+    end
+
+    def bytes_to_mb(bytes)
+      (bytes.to_f / (1024 * 1024)).round(2)
+    end
+
+    def calculate_status(size_bytes)
+      size_mb = bytes_to_mb(size_bytes)
+
+      if size_mb >= DANGER_THRESHOLD
+        :danger
+      elsif size_mb >= WARNING_THRESHOLD
+        :warning
+      else
+        :ok
+      end
+    end
+  end
+end

data/app/views/layouts/solidstats/application.html.erb

@@ -7,7 +7,8 @@
 
   <%= yield :head %>
 
-  <%= stylesheet_link_tag    "solidstats/application", media: "all" %>
+  <%= solidstats_styles %>
+  <%= solidstats_scripts %>
 </head>
 <body>