Class: Smplkit::Logging::LoggersClient

Inherits:
Object
  • Object
show all
Defined in:
lib/smplkit/logging/client.rb

Overview

Surface for client.logging.loggers.* (sync).

Logger CRUD plus the discovery buffer. The buffer is owned by the fused LoggingClient and shared here so discovery (driven by LoggingClient#install) and explicit register drain through one queue.

Instance Method Summary collapse

Constructor Details

#initialize(http_client, buffer:) ⇒ LoggersClient

Returns a new instance of LoggersClient.



96
97
98
99
 
# File 'lib/smplkit/logging/client.rb', line 96

def initialize(http_client, buffer:)
  @api = SmplkitGeneratedClient::Logging::LoggersApi.new(http_client)
  @buffer = buffer
end

Instance Method Details

#_update_logger(logger) ⇒ Object 



171
172
173
174
 
# File 'lib/smplkit/logging/client.rb', line 171

def _update_logger(logger)
  response = ApiSupport::ErrorMapping.call { @api.update_logger(logger.id || logger.name, logger_body(logger)) }
  Helpers.logger_resource_to_model(self, ApiSupport::ResourceShim.from_model(response.data))
end

#delete(id) ⇒ Object

Delete a logger by id.



166
167
168
169
 
# File 'lib/smplkit/logging/client.rb', line 166

def delete(id)
  ApiSupport::ErrorMapping.call { @api.delete_logger(id) }
  nil
end

#flush ⇒ Object

Drain the buffer and POST pending logger sources to the bulk endpoint.



121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/smplkit/logging/client.rb', line 121

def flush
  batch = @buffer.drain
  return if batch.empty?

  items = batch.map do |entry|
    SmplkitGeneratedClient::Logging::LoggerBulkItem.new(
      id: entry["id"], resolved_level: entry["resolved_level"], level: entry["level"],
      service: entry["service"], environment: entry["environment"]
    )
  end
  body = SmplkitGeneratedClient::Logging::LoggerBulkRequest.new(loggers: items)
  ApiSupport::ErrorMapping.call { @api.bulk_register_loggers(body) }
end

#flush_sync ⇒ Object

Synchronous flush — alias of flush for the periodic-flush path.



136
137
138
 
# File 'lib/smplkit/logging/client.rb', line 136

def flush_sync
  flush
end

#get(id) ⇒ Object

Fetch the editable SmplLogger resource by id.



160
161
162
163
 
# File 'lib/smplkit/logging/client.rb', line 160

def get(id)
  response = ApiSupport::ErrorMapping.call { @api.get_logger(id) }
  Helpers.logger_resource_to_model(self, ApiSupport::ResourceShim.from_model(response.data))
end

#get_logger_entry(id) ⇒ Object

Fetch one logger as a resolution-cache entry. Used by the logger_changed WS handler.



185
186
187
188
 
# File 'lib/smplkit/logging/client.rb', line 185

def get_logger_entry(id)
  response = ApiSupport::ErrorMapping.call { @api.get_logger(id) }
  logger_entry_from_resource(ApiSupport::ResourceShim.from_model(response.data))
end

#list(page_number: nil, page_size: nil) ⇒ Object

List loggers for the authenticated account.



151
152
153
154
155
156
157
 
# File 'lib/smplkit/logging/client.rb', line 151

def list(page_number: nil, page_size: nil)
  opts = {}
  opts[:page_number] = page_number unless page_number.nil?
  opts[:page_size] = page_size unless page_size.nil?
  response = ApiSupport::ErrorMapping.call { @api.list_loggers(opts) }
  (response.data || []).map { |r| Helpers.logger_resource_to_model(self, ApiSupport::ResourceShim.from_model(r)) }
end

#list_logger_entries ⇒ Object

Runtime entry — walks every page and returns an id-keyed Hash of resolution-cache entries (level, group, managed, environments).



178
179
180
181
 
# File 'lib/smplkit/logging/client.rb', line 178

def list_logger_entries
  rows = ApiSupport::PaginatedFetch.collect { |opts| @api.list_loggers(opts) }
  rows.to_h { |r| logger_entry_from_resource(ApiSupport::ResourceShim.from_model(r)) }
end

#new(id, managed: true) ⇒ Object

Return a new unsaved SmplLogger. Call SmplLogger#save to persist.



146
147
148
 
# File 'lib/smplkit/logging/client.rb', line 146

def new(id, managed: true)
  SmplLogger.new(self, id: id, name: id, resolved_level: nil, managed: managed)
end

#pending_count ⇒ Object

Number of sources queued and awaiting flush.



141
142
143
 
# File 'lib/smplkit/logging/client.rb', line 141

def pending_count
  @buffer.pending_count
end

#register(items, flush: false) ⇒ Object

Buffer logger sources for registration; optionally flush immediately.



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/smplkit/logging/client.rb', line 102

def register(items, flush: false)
  batch = items.is_a?(Array) ? items : [items]
  batch.each do |src|
    @buffer.add(LoggerSource.new(
                  name: Normalize.normalize_logger_name(src.name),
                  resolved_level: src.resolved_level, level: src.level,
                  service: src.service, environment: src.environment
                ))
  end
  if flush
    self.flush
    return
  end
  return unless @buffer.pending_count >= LOGGER_BATCH_FLUSH_SIZE

  Thread.new { threshold_flush }
end