legion-logging 1.2.5 → 1.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5c68f56d267c3653df2d9a713072d2ab81445f437f64761e23ebd4bc8323e73
-  data.tar.gz: f78f23e438594a7eab25499a154b27d9fb0d043c54773c72c2f63affb9aa76b6
+  metadata.gz: e397ca81de1cb74f71dc9f220e59406a8f8e6cbf2d9aae6092918f428588bc60
+  data.tar.gz: e41480464a27679090cc3bbff835c9a9c5c5f2c52fb60edd1096d1c8e7a43031
 SHA512:
-  metadata.gz: 05a90fe04d73b187c72bb1d5bdc732ae2b314670306174bf0430f0e996bab0ed7e76fa51209a7dd295c94f5b4bac173a67032de51f5d7d2e89fee5ddcf26c361
-  data.tar.gz: 2a3b358b39146cb6e7bb6971f5cd7e881a528df16bd8823bea4cfa7cd8877f09bb9d8c57770176274e1a44e09b2731a86ae39354cc1ba4966aa76685b7d36eeb
+  metadata.gz: 355eaf1cfe6d31c27360aadc06bdd6a81b6fa07c380ca68c5fd645089fe8ba81521ffd7971c078ed5f124c9e28e73babcbb390fcffcca46f5648ad3ee2839d24
+  data.tar.gz: c062f3e91ccc3a322cbbf8a539321207505c7e663623027e7d59354c63ac3eb692b93389ced67be17c7614b1578021e07dc7956ad0f1469e6cd4adb57d262629

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Legion::Logging Changelog
 
+## [Unreleased]
+
+## v1.2.7
+
+### Added
+- `Legion::Logging::Hooks`: callback registry for fatal/error/warn log events
+- `Legion::Logging::EventBuilder`: structured event payload builder with caller, exception, lex, and gem metadata
+- `on_fatal`, `on_error`, `on_warn` registration methods on `Legion::Logging`
+- `enable_hooks!`, `disable_hooks!`, `clear_hooks!` control methods
+- Hook dispatch wired into `fatal`, `error`, `warn` methods in `Methods` module
+
+## v1.2.6
+
+### Added
+- `Legion::Logging::Redactor`: PII/PHI redaction module with built-in patterns for SSN, email, phone, MRN, DOB, and credit card numbers
+- Sensitive field-name redaction: fields named `password`, `secret`, `token`, `api_key`, `authorization` are always fully redacted
+- Recursive redaction of nested hashes and arrays
+- Custom pattern support via `Legion::Settings[:logging, :redactor, :custom_patterns]`
+- `Legion::Logging::Shipper`: structured log event forwarding to external collectors with batch buffering and level filtering
+- `Legion::Logging::Shipper::FileTransport`: writes JSON-lines to rotated log files for pickup by Filebeat/Fluentd
+- `Legion::Logging::Shipper::HttpTransport`: POSTs JSON batches to HTTP endpoints (Splunk HEC, ELK Logstash)
+- All SIEM shipping features disabled by default; opt-in via `logging.shipper.enabled: true`
+
 ## v1.2.5
 
 ### Fixed

data/CLAUDE.md

@@ -8,16 +8,23 @@
 Ruby logging class for the LegionIO framework. Provides colorized console output via Rainbow, structured JSON logging (`format: :json`), and a consistent logging interface across all Legion gems and extensions.
 
 **GitHub**: https://github.com/LegionIO/legion-logging
+**Version**: 1.2.5
 **License**: Apache-2.0
 
 ## Architecture
 
 ```
 Legion::Logging (singleton module)
-├── Methods    # Log level methods: debug, info, warn, error, fatal, unknown
-├── Builder    # Output destination (stdout/file), log level, formatter
-├── Logger     # Core logger configuration and setup
-└── Version    # VERSION constant
+├── Methods         # Log level methods: debug, info, warn, error, fatal, unknown
+├── Builder         # Output destination (stdout/file), log level, formatter
+├── Hooks           # Callback registry for fatal/error/warn events (on_fatal, on_error, on_warn)
+├── EventBuilder    # Structured event payload builder (caller, exception, lex, gem metadata)
+├── Logger          # Core logger configuration and setup
+├── MultiIO         # Write to multiple destinations simultaneously
+├── SIEMExporter    # PHI-redacting SIEM export (Splunk HEC, ELK/OpenSearch)
+├── Shipper         # Buffered log event forwarding (file/http transports)
+├── Redactor        # PII/PHI pattern redaction
+└── Version         # VERSION constant
 ```
 
 ### Key Design Patterns
@@ -27,6 +34,10 @@ Legion::Logging (singleton module)
 - **Setup Method**: `Legion::Logging.setup(log_file:, level:)` configures output destination and level
 - **Structured JSON**: `format: :json` in settings outputs machine-parseable JSON log lines
 - **Shared Interface**: Same method signature (`info`, `warn`, `error`, etc.) across all Legion components
+- **MultiIO**: Splits writes to stdout and a log file simultaneously (used by Builder when `log_file` is set)
+- **SIEMExporter**: PHI redaction (SSN, phone, MRN, DOB patterns), `export_to_splunk` (HEC), `format_for_elk`
+- **Hook Callbacks**: `on_fatal`, `on_error`, `on_warn` register procs called after each log at those levels. Hooks are gated by `enable_hooks!`/`disable_hooks!`. Hook failures are silently rescued — never impact the logger.
+- **EventBuilder**: Builds structured event hashes from log context (caller location, exception info, lex identity, gem metadata). All from in-memory data, zero IO.
 
 ## Dependencies
 
@@ -43,6 +54,9 @@ Legion::Logging (singleton module)
 | `lib/legion/logging/builder.rb` | Output config and formatter |
 | `lib/legion/logging/logger.rb` | Core logger setup |
 | `lib/legion/logging/multi_io.rb` | Multi-output IO (write to multiple destinations simultaneously) |
+| `lib/legion/logging/siem_exporter.rb` | PHI-redacting SIEM export helpers (Splunk HEC, ELK format) |
+| `lib/legion/logging/hooks.rb` | Callback registry (fatal/error/warn hook arrays, enable/disable/clear) |
+| `lib/legion/logging/event_builder.rb` | Structured event payload builder |
 | `lib/legion/logging/version.rb` | VERSION constant |
 
 ## Role in LegionIO

data/Gemfile

@@ -3,6 +3,9 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem 'logger'
+
 group :test do
   gem 'rake'
   gem 'rspec'

data/README.md

@@ -1,6 +1,8 @@
 # legion-logging
 
-Logging module for the [LegionIO](https://github.com/LegionIO/LegionIO) framework. Provides colorized console output via Rainbow and a consistent logging interface across all Legion gems and extensions.
+Logging module for the [LegionIO](https://github.com/LegionIO/LegionIO) framework. Provides colorized console output via Rainbow, structured JSON logging, multi-output IO, and a consistent logging interface across all Legion gems and extensions.
+
+**Version**: 1.2.5
 
 ## Installation
 
@@ -39,6 +41,27 @@ Legion::Logging.setup(level: 'info', format: :json)
 
 This is useful for log aggregation pipelines (Elasticsearch, Splunk, etc.).
 
+### Multi-Output IO
+
+`Legion::Logging::MultiIO` writes to multiple destinations simultaneously — for example, stdout and a file at the same time. Used internally by the Builder when `log_file` is set alongside console output.
+
+### SIEM Export
+
+`Legion::Logging::SIEMExporter` provides PHI-redacting export helpers for security event pipelines:
+
+```ruby
+# Redact PHI patterns (SSN, phone, MRN, DOB) from a string
+clean = Legion::Logging::SIEMExporter.redact_phi(raw_message)
+
+# Export to Splunk HEC
+Legion::Logging::SIEMExporter.export_to_splunk(event, hec_url: url, token: token)
+
+# Format for ELK/OpenSearch
+Legion::Logging::SIEMExporter.format_for_elk(event, index: 'legion')
+```
+
+PHI patterns redacted: SSN (`###-##-####`), phone (`###-###-####`), MRN (`XX#######`), DOB (`##/##/####`).
+
 ## Requirements
 
 - Ruby >= 3.4

data/lib/legion/logging/event_builder.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Legion
+  module Logging
+    module EventBuilder
+      class << self
+        def build(level:, message:, lex: nil, lex_segments: nil, context: nil, caller_offset: 2) # rubocop:disable Metrics/ParameterLists
+          event = base_fields(level, message)
+          event[:lex] = derive_lex_source(lex, lex_segments)
+          add_node(event)
+          add_caller_info(event, caller_offset)
+          add_exception_info(event, message)
+          add_gem_info(event, event[:lex])
+          event[:context] = context if context
+          event.compact
+        end
+
+        private
+
+        def base_fields(level, message)
+          {
+            timestamp: Time.now.utc.iso8601(3),
+            level:     level,
+            message:   message.is_a?(Exception) ? message.message : strip_ansi(message.to_s),
+            pid:       ::Process.pid,
+            thread:    Thread.current.object_id
+          }
+        end
+
+        def derive_lex_source(lex, lex_segments)
+          if lex_segments.is_a?(Array) && !lex_segments.empty?
+            "lex-#{lex_segments.join('-')}"
+          elsif lex && !lex.to_s.empty?
+            "lex-#{lex}"
+          end
+        end
+
+        def add_node(event)
+          return unless defined?(Legion::Settings)
+
+          name = begin
+            Legion::Settings[:client][:name]
+          rescue StandardError
+            nil
+          end
+          event[:node] = name if name
+        end
+
+        def add_caller_info(event, offset)
+          loc = caller_locations(offset + 1, 1)&.first
+          return unless loc
+
+          event[:caller] = {
+            file:     loc.absolute_path || loc.path,
+            function: loc.base_label,
+            line:     loc.lineno
+          }
+        end
+
+        def add_exception_info(event, message)
+          return unless message.is_a?(Exception)
+
+          event[:exception] = {
+            class:   message.class.name,
+            message: message.message
+          }
+          event[:backtrace] = message.backtrace if message.backtrace
+        end
+
+        def add_gem_info(event, lex_source)
+          return unless lex_source
+
+          spec = Gem::Specification.find_by_name(lex_source)
+          event[:gem] = {
+            name:            spec.name,
+            version:         spec.version.to_s,
+            source_code_uri: spec.metadata['source_code_uri'],
+            homepage:        spec.metadata['homepage_uri'] || spec.homepage,
+            path:            spec.full_gem_path
+          }.compact
+        rescue Gem::MissingSpecError, ArgumentError
+          nil
+        end
+
+        def strip_ansi(str)
+          str.gsub(/\e\[[0-9;]*m/, '')
+        end
+      end
+    end
+  end
+end

data/lib/legion/logging/hooks.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module Logging
+    module Hooks
+      @hooks = { fatal: [], error: [], warn: [] }
+      @enabled = false
+
+      class << self
+        attr_reader :hooks
+
+        def enabled?
+          @enabled
+        end
+
+        def enable!
+          @enabled = true
+        end
+
+        def disable!
+          @enabled = false
+        end
+
+        def clear!
+          @hooks.each_value(&:clear)
+        end
+
+        def register(level, &block)
+          @hooks[level] << block
+        end
+
+        def fire(level, event)
+          return unless @enabled
+          return if @hooks[level].empty?
+
+          @hooks[level].each do |hook|
+            hook.call(event)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/logging/logger.rb

@@ -12,6 +12,7 @@ module Legion
       include Legion::Logging::Builder
 
       def initialize(level: 'info', log_file: nil, log_stdout: nil, lex: nil, trace: false, extended: false, trace_size: 4, format: :text, **opts) # rubocop:disable Metrics/ParameterLists
+        @lex = lex
         set_log(logfile: log_file, log_stdout: log_stdout)
         log_level(level)
         log_format(format: format, lex: lex, extended: extended, **opts)

data/lib/legion/logging/methods.rb

@@ -37,24 +37,30 @@ module Legion
         return unless log.level < 3
 
         message = yield if message.nil? && block_given?
+        raw = message
         message = Rainbow(message).yellow if @color
         log.warn(message)
+        fire_hooks(:warn, raw)
       end
 
       def error(message = nil)
         return unless log.level < 4
 
         message = yield if message.nil? && block_given?
+        raw = message
         message = Rainbow(message).red if @color
         log.error(message)
+        fire_hooks(:error, raw)
       end
 
       def fatal(message = nil)
         return unless log.level < 5
 
         message = yield if message.nil? && block_given?
+        raw = message
         message = Rainbow(message).darkred if @color
         log.fatal(message)
+        fire_hooks(:fatal, raw)
       end
 
       def unknown(message = nil)
@@ -77,6 +83,25 @@ module Legion
           Thread.current.object_id.to_s
         end
       end
+
+      private
+
+      def fire_hooks(level, message)
+        return unless Legion::Logging::Hooks.enabled?
+        return if Legion::Logging::Hooks.hooks[level].empty?
+
+        lex_val  = instance_variable_defined?(:@lex) ? @lex : nil
+        lex_segs = instance_variable_defined?(:@lex_segments) ? @lex_segments : nil
+
+        event = Legion::Logging::EventBuilder.build(
+          level:         level,
+          message:       message,
+          lex:           lex_val,
+          lex_segments:  lex_segs,
+          caller_offset: 4
+        )
+        Legion::Logging::Hooks.fire(level, event)
+      end
     end
   end
 end

data/lib/legion/logging/redactor.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Legion
+  module Logging
+    module Redactor
+      PATTERNS = {
+        ssn:         /\b\d{3}-\d{2}-\d{4}\b/,
+        email:       /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/,
+        phone:       /\b(?:\+1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/,
+        mrn:         /\bMRN[:\s]*\d{6,10}\b/i,
+        dob:         %r{\bDOB[:\s]*\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b}i,
+        credit_card: /\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/
+      }.freeze
+
+      SENSITIVE_FIELDS = %w[password secret token api_key authorization].freeze
+
+      REDACTED = '[REDACTED]'
+
+      class << self
+        def redact(event)
+          return event unless event.is_a?(Hash)
+
+          event.each_with_object({}) do |(key, value), result|
+            result[key] = sensitive_field?(key) ? REDACTED : redact_value(value)
+          end
+        end
+
+        def redact_value(value)
+          case value
+          when String then redact_string(value)
+          when Hash   then redact(value)
+          when Array  then value.map { |v| redact_value(v) }
+          else value
+          end
+        end
+
+        def redact_string(str)
+          result = str.dup
+          all_patterns.each_value { |pattern| result.gsub!(pattern, REDACTED) }
+          result
+        end
+
+        private
+
+        def sensitive_field?(key)
+          SENSITIVE_FIELDS.include?(key.to_s.downcase)
+        end
+
+        def all_patterns
+          @all_patterns ||= build_patterns
+        end
+
+        def build_patterns
+          patterns = PATTERNS.dup
+          custom = custom_patterns
+          custom.each { |name, regex| patterns[name.to_sym] = regex }
+          patterns
+        end
+
+        def custom_patterns
+          return {} unless defined?(Legion::Settings)
+
+          raw = Legion::Settings[:logging, :redactor, :custom_patterns]
+          return {} unless raw.is_a?(Hash)
+
+          raw.each_with_object({}) do |(name, pattern_str), acc|
+            acc[name] = Regexp.new(pattern_str)
+          rescue RegexpError
+            # skip invalid patterns
+          end
+        end
+
+        def reset_pattern_cache!
+          @all_patterns = nil
+        end
+      end
+    end
+  end
+end

data/lib/legion/logging/shipper/file_transport.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+
+module Legion
+  module Logging
+    module Shipper
+      module FileTransport
+        DEFAULT_PATH = '/var/log/legion/siem.log'
+
+        class << self
+          def ship(event)
+            path = resolve_path
+            FileUtils.mkdir_p(File.dirname(path))
+            File.open(path, 'a') do |f|
+              f.puts(::JSON.generate(event))
+            end
+            true
+          rescue StandardError => e
+            Legion::Logging.error("FileTransport ship failed: #{e.message}") if defined?(Legion::Logging)
+            false
+          end
+
+          private
+
+          def resolve_path
+            return settings_path if settings_path
+
+            DEFAULT_PATH
+          end
+
+          def settings_path
+            return nil unless defined?(Legion::Settings)
+
+            Legion::Settings[:logging, :shipper, :file, :path]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/logging/shipper/http_transport.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+module Legion
+  module Logging
+    module Shipper
+      module HttpTransport
+        class << self
+          def ship(events)
+            endpoint = resolve_endpoint
+            return false unless endpoint
+
+            uri   = URI(endpoint)
+            batch = Array(events)
+            body  = build_body(batch, uri)
+
+            response = post(uri, body)
+            response.is_a?(Net::HTTPSuccess)
+          rescue StandardError => e
+            Legion::Logging.error("HttpTransport ship failed: #{e.message}") if defined?(Legion::Logging)
+            false
+          end
+
+          private
+
+          def post(uri, body)
+            req = Net::HTTP::Post.new(uri)
+            req['Content-Type'] = 'application/json'
+            apply_auth(req)
+
+            Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https',
+                                                     open_timeout: 5, read_timeout: 10) do |http|
+              http.request(req, body)
+            end
+          end
+
+          def build_body(events, uri)
+            # Splunk HEC expects { event: ... } per event; others expect an array
+            if splunk_hec?(uri)
+              events.map { |e| ::JSON.generate({ event: e, time: Time.now.to_f }) }.join("\n")
+            else
+              ::JSON.generate(events)
+            end
+          end
+
+          def splunk_hec?(uri)
+            uri.path.include?('/services/collector')
+          end
+
+          def apply_auth(req)
+            token = auth_token
+            return unless token
+
+            req['Authorization'] = if splunk_hec?(URI(req.path.empty? ? '/' : req.uri&.to_s || '/'))
+                                     "Splunk #{token}"
+                                   else
+                                     "Bearer #{token}"
+                                   end
+          end
+
+          def auth_token
+            return nil unless defined?(Legion::Settings)
+
+            Legion::Settings[:logging, :shipper, :auth_token]
+          end
+
+          def resolve_endpoint
+            return nil unless defined?(Legion::Settings)
+
+            Legion::Settings[:logging, :shipper, :endpoint]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/logging/shipper.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative 'redactor'
+require_relative 'shipper/file_transport'
+require_relative 'shipper/http_transport'
+
+module Legion
+  module Logging
+    module Shipper
+      LEVEL_ORDER = %w[debug info warn error fatal].freeze
+
+      TRANSPORTS = {
+        file: FileTransport,
+        http: HttpTransport
+      }.freeze
+
+      class << self
+        def ship(event)
+          return unless enabled?
+          return unless shippable_level?(event[:level] || event['level'])
+
+          redacted  = Redactor.redact(event)
+          transport = TRANSPORTS[transport_type]
+          buffer_event(redacted) if transport
+        end
+
+        def flush
+          return if @buffer.nil? || @buffer.empty?
+
+          transport = TRANSPORTS[transport_type]
+          return unless transport
+
+          batch = nil
+          @mutex.synchronize do
+            batch = @buffer.dup
+            @buffer.clear
+          end
+
+          deliver(transport, batch)
+        end
+
+        def start
+          return unless enabled?
+          return if @flush_thread&.alive?
+
+          @buffer = []
+          @mutex  = Mutex.new
+          interval = flush_interval
+          @flush_thread = Thread.new do
+            loop do
+              sleep interval
+              flush
+            end
+          end
+          @flush_thread.abort_on_exception = false
+        end
+
+        def stop
+          @flush_thread&.kill
+          @flush_thread = nil
+          flush
+        end
+
+        def enabled?
+          return false unless defined?(Legion::Settings)
+
+          Legion::Settings[:logging, :shipper, :enabled] == true
+        end
+
+        private
+
+        def buffer_event(event)
+          @buffer  ||= []
+          @mutex   ||= Mutex.new
+
+          full = false
+          @mutex.synchronize do
+            @buffer << event
+            full = @buffer.size >= batch_size
+          end
+
+          flush if full
+        end
+
+        def deliver(transport, batch)
+          if transport.method(:ship).arity == 1
+            # HttpTransport accepts a batch array
+            transport.ship(batch)
+          else
+            batch.each { |e| transport.ship(e) }
+          end
+        rescue StandardError => e
+          Legion::Logging.error("Shipper deliver failed: #{e.message}") if defined?(Legion::Logging)
+        end
+
+        def shippable_level?(level)
+          return true if level.nil?
+
+          min = minimum_level
+          LEVEL_ORDER.index(level.to_s.downcase).to_i >= LEVEL_ORDER.index(min).to_i
+        end
+
+        def transport_type
+          return :file unless defined?(Legion::Settings)
+
+          key = Legion::Settings[:logging, :shipper, :transport]
+          key ? key.to_sym : :file
+        end
+
+        def batch_size
+          return 100 unless defined?(Legion::Settings)
+
+          Legion::Settings[:logging, :shipper, :batch_size] || 100
+        end
+
+        def flush_interval
+          return 5 unless defined?(Legion::Settings)
+
+          Legion::Settings[:logging, :shipper, :flush_interval] || 5
+        end
+
+        def minimum_level
+          return 'warn' unless defined?(Legion::Settings)
+
+          levels = Legion::Settings[:logging, :shipper, :levels]
+          return 'warn' unless levels.is_a?(Array) && !levels.empty?
+
+          levels.min_by { |l| LEVEL_ORDER.index(l.to_s) || 99 }.to_s
+        end
+      end
+    end
+  end
+end

data/lib/legion/logging/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Logging
-    VERSION = '1.2.5'
+    VERSION = '1.2.7'
   end
 end

data/lib/legion/logging.rb

@@ -4,6 +4,8 @@ require 'legion/logging/version'
 require 'legion/logging/logger'
 require 'legion/logging/methods'
 require 'legion/logging/builder'
+require 'legion/logging/hooks'
+require 'legion/logging/event_builder'
 
 require 'json'
 require 'logger'
@@ -15,6 +17,13 @@ module Legion
       include Legion::Logging::Methods
       include Legion::Logging::Builder
 
+      def on_fatal(&)  = Hooks.register(:fatal, &)
+      def on_error(&)  = Hooks.register(:error, &)
+      def on_warn(&)   = Hooks.register(:warn, &)
+      def enable_hooks!     = Hooks.enable!
+      def disable_hooks!    = Hooks.disable!
+      def clear_hooks!      = Hooks.clear!
+
       attr_reader :color
 
       def setup(level: 'info', format: :text, **options)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-logging
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 1.2.7
 platform: ruby
 authors:
 - Esity
@@ -58,9 +58,15 @@ files:
 - legion-logging.gemspec
 - lib/legion/logging.rb
 - lib/legion/logging/builder.rb
+- lib/legion/logging/event_builder.rb
+- lib/legion/logging/hooks.rb
 - lib/legion/logging/logger.rb
 - lib/legion/logging/methods.rb
 - lib/legion/logging/multi_io.rb
+- lib/legion/logging/redactor.rb
+- lib/legion/logging/shipper.rb
+- lib/legion/logging/shipper/file_transport.rb
+- lib/legion/logging/shipper/http_transport.rb
 - lib/legion/logging/siem_exporter.rb
 - lib/legion/logging/version.rb
 - sonar-project.properties