Class: Makit::Logging::Configuration

Inherits:
Object
  • Object
show all
Defined in:
lib/makit/logging/configuration.rb

Overview

Configuration management for unified logging

Provides schema validation, default configurations, and helper methods for setting up the unified file sink with various output configurations.

Examples:

Basic configuration

config = Configuration.new(
  configurations: [
    { file: $stdout, format: :console },
    { file: "logs/app.log", format: :json }
  ]
)

YAML configuration

config = Configuration.from_yaml("config/logging.yml")

Environment-based configuration

config = Configuration.for_environment(:production)

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(configurations: []) ⇒ Configuration

Initialize configuration

Parameters:

  • configurations (Array<Hash>) (defaults to: []) —

    list of output configurations



30
31
32
 
# File 'lib/makit/logging/configuration.rb', line 30

def initialize(configurations: [])
  @configurations = configurations
end

Instance Attribute Details

#configurations ⇒ Array<Hash> (readonly)

Returns list of output configurations.

Returns:

  • (Array<Hash>) —

    list of output configurations



25
26
27
 
# File 'lib/makit/logging/configuration.rb', line 25

def configurations
  @configurations
end

Class Method Details

.ci_config ⇒ Configuration

Get CI/CD configuration

Returns:



171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/makit/logging/configuration.rb', line 171

def self.ci_config
  new(
    configurations: [
      {
        file: $stdout,
        format: :console,
        show_level: true,
      },
      {
        file: "artifacts/build.log",
        format: :json,
        append: true,
        include_metadata: true,
      },
    ],
  )
end

.default_config ⇒ Configuration

Get default configuration

Returns:



90
91
92
93
94
95
96
97
98
 
# File 'lib/makit/logging/configuration.rb', line 90

def self.default_config
  require_relative "../logging" unless defined?(Makit::Logging)
  new(
    configurations: [
      { file: $stdout, format: :console },
      { file: Makit::Logging.log_file_path("makit.log"), format: :json, append: true },
    ],
  )
end

.development_config ⇒ Configuration

Get development configuration

Returns:



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/makit/logging/configuration.rb', line 103

def self.development_config
  new(
    configurations: [
      {
        file: $stdout,
        format: :console,
        show_timestamp: true,
        show_level: true,
      },
      {
        file: "logs/development.log",
        format: :text,
        append: true,
        include_context: true,
      },
      {
        file: "logs/debug.log",
        format: :json,
        append: true,
        min_level: :debug,
      },
    ],
  )
end

.for_environment(environment) ⇒ Configuration

Create environment-specific configuration

Parameters:

  • environment (Symbol) —

    environment name (:development, :production, :test)

Returns:



72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/makit/logging/configuration.rb', line 72

def self.for_environment(environment)
  case environment
  when :development
    development_config
  when :production
    production_config
  when :test
    test_config
  when :ci
    ci_config
  else
    default_config
  end
end

.from_json(json_file) ⇒ Configuration

Create configuration from JSON file

Parameters:

  • json_file (String) —

    path to JSON configuration file

Returns:



55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/makit/logging/configuration.rb', line 55

def self.from_json(json_file)
  require "json"
  data = JSON.parse(File.read(json_file))
  configurations = data["logging"]["sinks"] || []

  # Convert string keys to symbols
  configurations = configurations.map do |config|
    config.transform_keys(&:to_sym)
  end

  new(configurations: configurations)
end

.from_yaml(yaml_file) ⇒ Configuration

Create configuration from YAML file

Parameters:

  • yaml_file (String) —

    path to YAML configuration file

Returns:



38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/makit/logging/configuration.rb', line 38

def self.from_yaml(yaml_file)
  require "yaml"
  data = YAML.load_file(yaml_file)
  configurations = data["logging"]["sinks"] || []

  # Convert string keys to symbols
  configurations = configurations.map do |config|
    config.transform_keys(&:to_sym)
  end

  new(configurations: configurations)
end

.production_config ⇒ Configuration

Get production configuration

Returns:



131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/makit/logging/configuration.rb', line 131

def self.production_config
  new(
    configurations: [
      {
        file: "logs/application.log",
        format: :json,
        append: true,
        include_metadata: true,
        rotation: { max_size: "100MB", max_files: 10 },
      },
      {
        file: "logs/errors.log",
        format: :json,
        append: true,
        min_level: :error,
        include_metadata: true,
      },
    ],
  )
end

.test_config ⇒ Configuration

Get test configuration

Returns:



155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'lib/makit/logging/configuration.rb', line 155

def self.test_config
  new(
    configurations: [
      {
        file: "logs/test.log",
        format: :text,
        append: false,
        include_context: true,
      },
    ],
  )
end

Instance Method Details

#save_json(json_file) ⇒ void

This method returns an undefined value.

Save configuration to JSON file

Parameters:

  • json_file (String) —

    path to JSON file



239
240
241
242
243
 
# File 'lib/makit/logging/configuration.rb', line 239

def save_json(json_file)
  require "json"
  FileUtils.mkdir_p(File.dirname(json_file))
  File.write(json_file, JSON.pretty_generate(to_hash))
end

#save_yaml(yaml_file) ⇒ void

This method returns an undefined value.

Save configuration to YAML file

Parameters:

  • yaml_file (String) —

    path to YAML file



229
230
231
232
233
 
# File 'lib/makit/logging/configuration.rb', line 229

def save_yaml(yaml_file)
  require "yaml"
  FileUtils.mkdir_p(File.dirname(yaml_file))
  File.write(yaml_file, to_hash.to_yaml)
end

#to_hash ⇒ Hash

Get configuration as hash

Returns:

  • (Hash) —

    configuration as hash



217
218
219
220
221
222
223
 
# File 'lib/makit/logging/configuration.rb', line 217

def to_hash
  {
    logging: {
      sinks: @configurations,
    },
  }
end

#valid? ⇒ Boolean

Check if configuration is valid

Returns:

  • (Boolean) —

    true if valid



207
208
209
210
211
212
 
# File 'lib/makit/logging/configuration.rb', line 207

def valid?
  validate!
  true
rescue ArgumentError
  false
end

#validate! ⇒ Boolean

Validate configuration

Returns:

  • (Boolean) —

    true if valid

Raises:

  • (ArgumentError) —

    if configuration is invalid



193
194
195
196
197
198
199
200
201
202
 
# File 'lib/makit/logging/configuration.rb', line 193

def validate!
  raise ArgumentError, "configurations must be an array" unless @configurations.is_a?(Array)
  raise ArgumentError, "at least one configuration is required" if @configurations.empty?

  @configurations.each_with_index do |config, index|
    validate_single_configuration(config, index)
  end

  true
end