logger_head 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c9468862f9d5144ae46bea82b1758d8aeff9e4c6d8411d080769df19b2047734
+  data.tar.gz: f4e3fbfd161c1464b14dadff378a83342b33bd16e93dbeb77f33c8c4d34f5967
+SHA512:
+  metadata.gz: a83a13eec52d7c483afefa6b66bd832f18c34e4a075214b2fb42a507e34e958b2621a21576f970fd5ecef43838755aabc796936019b4257f431eeefed205f96b
+  data.tar.gz: 0e341aebd3d17c2754fadd492205c2cdf91d03ac72aaf51e19978a302cee6eaa4398390293e2b822566058fc043b89b3fa7d3f3e6fb87759ae3b3c8964938494

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/README.md

@@ -0,0 +1,155 @@
+# LoggerHead
+
+A simple structured error logging utility with context support for Ruby applications. LoggerHead provides structured error logging with contextual information for better debugging and error tracking.
+
+Originally extracted from DetectionTek patterns, LoggerHead offers consistent error logging that works in both Rails and non-Rails environments.
+
+## Features
+
+- **Structured Error Logging**: Logs errors with contextual information
+- **Automatic Backtrace Logging**: Captures and logs full error backtraces
+- **Context-Aware**: Allows adding descriptive context to errors for better debugging
+- **Environment Agnostic**: Works with Rails.logger or standard Ruby Logger
+- **Zero Dependencies**: Pure Ruby with no external dependencies
+- **Simple API**: Easy to integrate into existing codebases
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'logger_head'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install logger_head
+```
+
+## Usage
+
+### Basic Usage
+
+```ruby
+require 'logger_head'
+
+begin
+  # Some operation that might fail
+  raise StandardError, "Something went wrong"
+rescue => error
+  # Log with context
+  LoggerHead.new(error, provided_context: "during user creation").call
+end
+```
+
+### With Custom Context
+
+```ruby
+# Log error with specific context
+error = StandardError.new("Database connection failed")
+LoggerHead.new(error, provided_context: "in payment processing").call
+
+# Output:
+# ERROR -- : There was an error in payment processing: Database connection failed
+# ERROR -- : /path/to/file:123:in `method_name'
+#           /path/to/file:456:in `other_method'
+#           ...
+```
+
+### In Rails Applications
+
+LoggerHead automatically uses `Rails.logger` when available:
+
+```ruby
+class UsersController < ApplicationController
+  def create
+    User.create!(user_params)
+  rescue => error
+    LoggerHead.new(error, provided_context: "creating user #{params[:name]}").call
+    render json: { error: "User creation failed" }, status: 422
+  end
+end
+```
+
+### In Service Objects
+
+```ruby
+class CreateUserService
+  def call
+    # ... service logic
+  rescue => error
+    LoggerHead.new(error, provided_context: "in #{self.class.name}").call
+    # Handle error appropriately
+  end
+end
+```
+
+### Integration with Hmibo
+
+LoggerHead is integrated into the [Hmibo gem](https://github.com/wendcare/hmibo) for service object patterns:
+
+```ruby
+class MyService < Hmibo::Base
+  def perform
+    # Any errors are automatically logged with LoggerHead
+    raise StandardError, "Something went wrong"
+  end
+end
+
+# Automatically logs: "There was an error in MyService execution: Something went wrong"
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## API Reference
+
+### LoggerHead.new(error, provided_context: nil)
+
+Creates a new LoggerHead instance.
+
+**Parameters:**
+- `error` (Exception): The error/exception to log
+- `provided_context` (String, optional): Additional context information
+
+**Returns:** LoggerHead instance
+
+### #call
+
+Executes the logging operation, writing both the error message and backtrace to the logger.
+
+**Returns:** nil
+
+## Testing
+
+The gem includes a comprehensive test suite. Run tests with:
+
+```bash
+bundle exec rspec
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/detectiontek/logger_head.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Write tests for your changes
+4. Ensure all tests pass (`bundle exec rspec`)
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create a new Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/logger_head/version.rb

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

data/lib/logger_head.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "logger_head/version"
+
+class LoggerHead
+  VERSION = LoggerHeadGem::VERSION
+
+  def initialize(error, provided_context: nil)
+    @error = error
+    @provided_context = provided_context
+  end
+
+  def call
+    log_error
+    log_backtrace
+  end
+
+  def log_error
+    boilerplate = "There was an error"
+    error_context = [boilerplate, provided_context].compact.join(" ")
+    logger.error "#{error_context}: #{error.message}"
+  end
+
+  def log_backtrace
+    logger.error error.backtrace&.join("\n")
+  end
+
+  private
+
+  attr_reader :error, :provided_context
+
+  def logger
+    @logger ||= if defined?(Rails)
+                  Rails.logger
+                else
+                  require 'logger'
+                  Logger.new($stdout)
+                end
+  end
+end

data/sig/logger_head.rbs

@@ -0,0 +1,4 @@
+module LoggerHead
+  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: logger_head
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dan Brown
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-07-19 00:00:00.000000000 Z
+dependencies: []
+description: LoggerHead provides structured error logging with contextual information
+  for better debugging and error tracking in Ruby applications.
+email:
+- dbrown@occameducation.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- README.md
+- Rakefile
+- lib/logger_head.rb
+- lib/logger_head/version.rb
+- sig/logger_head.rbs
+homepage: https://github.com/detectiontek/logger_head
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/detectiontek/logger_head
+  changelog_uri: https://github.com/detectiontek/logger_head/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A simple structured error logging utility with context support
+test_files: []