Class: Roby::EventLogging::DRobyEventLogger

Inherits:
Object
  • Object
show all
Defined in:
lib/roby/event_logging/droby_event_logger.rb

Overview

Object that acts as an observer for ExecutablePlan, handling the droby marshalling/demarshalling. Dumping to IO is delegated to #logfile, a separate object that must provide a #dump method the way Logfile::Writer does

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(logfile, queue_size: 50, log_timepoints: false) ⇒ DRobyEventLogger

Returns a new instance of DRobyEventLogger.

Parameters:

  • marshal (#dump) —

    the object that transforms the arguments into droby-compatible objects

  • queue_size (Integer) (defaults to: 50) —

    if non-zero, the access to I/O will be done in a separate thread, and this parameter is the maximum amount of cycles that can be queued in a backlog until the main thread waits on the logger



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 64

def initialize(logfile, queue_size: 50, log_timepoints: false)
    @stats_mode = false
    @logfile = logfile
    @object_manager = DRoby::ObjectManager.new(nil)
    @marshal = DRoby::Marshal.new(object_manager, nil)
    @current_cycle = []
    @sync = true
    @dump_time = 0
    @mutex = Mutex.new
    @log_timepoints = log_timepoints

    return unless queue_size > 0

    @dump_queue  = SizedQueue.new(queue_size)
    @dump_thread = Thread.new(&method(:dump_loop))
end

Instance Attribute Details

#current_cycle ⇒ Object (readonly)

The set of events for the current cycle. This is dumped only when the cycle_end event is received



17
18
19
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 17

def current_cycle
  @current_cycle
end

#dump_time ⇒ Object (readonly)

The time spent logging so far



30
31
32
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 30

def dump_time
  @dump_time
end

#logfile ⇒ #dump (readonly)

The object that will be given the cycles to be written

Returns:



13
14
15
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 13

def logfile
  @logfile
end

#marshal ⇒ DRoby::Marshal (readonly)

The marshalling object

Returns:



27
28
29
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 27

def marshal
  @marshal
end

#object_manager ⇒ DRoby::ObjectManager (readonly)

The object manager

Returns:



22
23
24
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 22

def object_manager
  @object_manager
end

Instance Method Details

#append_message(name, time, args) ⇒ Object 



121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 121

def append_message(name, time, args)
    args =
        case name
        when :merged_plan
            process_merged_plan(args)
        when :finalized_task
            process_finalized_task(args)
        when :finalized_event
            process_finalized_event(args)
        else
            marshal.dump(args)
        end

    @current_cycle << name << time.tv_sec << time.tv_usec << args
end

#close ⇒ Object

Close this logger, flushing the remaining data to I/O



112
113
114
115
116
117
118
119
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 112

def close
    if threaded?
        @dump_queue.push nil
        @dump_thread.join
    end
ensure
    logfile.close
end

#dump(name, time, args) ⇒ Object

Dump one log message



175
176
177
178
179
180
181
182
183
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 175

def dump(name, time, args)
    return if stats_mode?

    start = Time.now
    synchronize do
        append_message(name, time, args)
    end
ensure @dump_time += (Time.now - start)
end

#dump_loop ⇒ Object

Main dump loop if the logger is threaded



205
206
207
208
209
210
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 205

def dump_loop
    while (cycle = @dump_queue.pop)
        logfile.dump(cycle)
        logfile.flush if sync?
    end
end

#dump_timepoint(event, time, args) ⇒ Object 



166
167
168
169
170
171
172
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 166

def dump_timepoint(event, time, args)
    return if stats_mode? || !log_timepoints?

    synchronize do
        @current_cycle << event << time.tv_sec << time.tv_usec << args
    end
end

#flush ⇒ Object 



100
101
102
103
104
105
106
107
108
109
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 100

def flush
    if threaded?
        @dump_queue.push nil
        @dump_thread.join
        logfile.flush
        @dump_thread = Thread.new(&method(:dump_loop))
    else
        logfile.flush
    end
end

#flush_cycle(*last_message) ⇒ Object 



185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 185

def flush_cycle(*last_message)
    start = Time.now
    if threaded?
        @dump_thread.value unless @dump_thread.alive?

        synchronize do
            append_message(*last_message)
            @dump_queue << @current_cycle
            @current_cycle = []
        end
    else
        append_message(*last_message)
        logfile.dump(@current_cycle)
        logfile.flush if sync?
        @current_cycle.clear
    end
ensure @dump_time += (Time.now - start)
end

#log_queue_size ⇒ Object 



89
90
91
92
93
94
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 89

def log_queue_size
    if threaded? then @dump_queue.size
    else
        0
    end
end

#log_timepoints=(flag) ⇒ Object

Controls whether the logger should save generated timepoints or ignore them. This makes the logs bigger by an order of magnitude (at least)



38
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 38

attr_predicate :log_timepoints, true

#log_timepoints? ⇒ Object

Controls whether the logger should save generated timepoints or ignore them. This makes the logs bigger by an order of magnitude (at least)



38
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 38

attr_predicate :log_timepoints, true

#process_finalized_event(args) ⇒ Object 



159
160
161
162
163
164
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 159

def process_finalized_event(args)
    task = args[1]
    args = marshal.dump(args)
    object_manager.deregister_object(task)
    args
end

#process_finalized_task(args) ⇒ Object 



152
153
154
155
156
157
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 152

def process_finalized_task(args)
    task = args[1]
    args = marshal.dump(args)
    object_manager.deregister_object(task)
    args
end

#process_merged_plan(args) ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 137

def process_merged_plan(args)
    plan_id, merged_plan = *args

    merged_plan.tasks.each do |t|
        object_manager.register_object(t)
    end
    merged_plan.free_events.each do |e|
        object_manager.register_object(e)
    end
    merged_plan.task_events.each do |e|
        object_manager.register_object(e)
    end
    [plan_id, merged_plan.droby_dump(marshal)]
end

#register_executable_plan(plan) ⇒ Object 



81
82
83
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 81

def register_executable_plan(plan)
    dump(:register_executable_plan, Time.now, [plan.droby_id])
end

#stats_mode=(flag) ⇒ Object

Controls whether the logger should only dump statistics, or the full set of plan events



45
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 45

attr_predicate :stats_mode, true

#stats_mode? ⇒ Object

Controls whether the logger should only dump statistics, or the full set of plan events



45
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 45

attr_predicate :stats_mode, true

#sync=(flag) ⇒ Object

Controls whether log data should be flushed on disk after each cycle. It is set by default. Disable for improved performance if the data will not be displayed live

Application disables it by default if the log server is disabled



56
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 56

attr_predicate :sync?, true

#sync? ⇒ Object

Controls whether log data should be flushed on disk after each cycle. It is set by default. Disable for improved performance if the data will not be displayed live

Application disables it by default if the log server is disabled



56
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 56

attr_predicate :sync?, true

#synchronize(&block) ⇒ Object 



85
86
87
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 85

def synchronize(&block)
    @mutex.synchronize(&block)
end

#threaded? ⇒ Boolean

Returns:

  • (Boolean) 


96
97
98
 
# File 'lib/roby/event_logging/droby_event_logger.rb', line 96

def threaded?
    @dump_queue
end