static FilterReplyResult filter_apply(FilterReplyResultBase * const rb,
const struct sockaddr_storage * const sa_local,
const socklen_t sa_local_len,
const struct sockaddr_storage * const sa_remote,
const socklen_t sa_remote_len,
void *buf, size_t * const nbyte)
{
msgpack_packer * const msgpack_packer = rb->filter->msgpack_packer;
filter_before_apply(rb, 1U, "read",
sa_local, sa_local_len, sa_remote, sa_remote_len);
if (rb->pre != false) {
msgpack_pack_mstring(msgpack_packer, "nbyte");
msgpack_pack_unsigned_long(msgpack_packer, *nbyte);
} else if (*rb->ret <= 0) {
msgpack_pack_mstring(msgpack_packer, "data");
msgpack_pack_nil(msgpack_packer);
} else {
assert((size_t) *rb->ret <= *nbyte);
msgpack_pack_mstring(msgpack_packer, "data");
msgpack_pack_raw(msgpack_packer, *rb->ret);
msgpack_pack_raw_body(msgpack_packer, buf, *rb->ret);
}
if (filter_send_message(rb->filter) != 0) {
return FILTER_REPLY_RESULT_ERROR;
}
return filter_parse_reply(rb, buf, nbyte);
}
static void pack_cpu_sample_event(rbkit_cpu_sample_event *event, msgpack_packer *packer) {
rbkit_cpu_sample *sample;
size_t count;
msgpack_pack_map(packer, 3);
sample = event->sample;
// Keys 1 & 2 - event type and timestamp
pack_event_header(packer, event->event_header.event_type);
// Key 3 : Payload
msgpack_pack_int(packer, rbkit_message_field_payload);
// Value 3: Array of samples
msgpack_pack_array(packer, sample->frame_count);
for(count = 0; count != sample->frame_count; count++){
msgpack_pack_map(packer, 6);
// method_name
msgpack_pack_int(packer, rbkit_message_field_method_name);
pack_string(packer, sample->frames[count].method_name);
// label
msgpack_pack_int(packer, rbkit_message_field_label);
pack_string(packer, sample->frames[count].label);
// file
msgpack_pack_int(packer, rbkit_message_field_file);
pack_string(packer, sample->frames[count].file);
// line
msgpack_pack_int(packer, rbkit_message_field_line);
msgpack_pack_unsigned_long(packer, sample->frames[count].line);
// singleton_method
msgpack_pack_int(packer, rbkit_message_field_singleton_method);
msgpack_pack_int(packer, sample->frames[count].is_singleton_method);
// thread_od
msgpack_pack_int(packer, rbkit_message_field_thread_id);
msgpack_pack_unsigned_long(packer, sample->frames[count].thread_id);
}
}
static void pack_event_collection_event(rbkit_event_collection_event *event, msgpack_packer *packer) {
msgpack_sbuffer *sbuf = packer->data;
msgpack_pack_map(packer, 4);
pack_event_header(packer, event->event_header.event_type);
msgpack_pack_int(packer, rbkit_message_field_message_counter);
msgpack_pack_unsigned_long(packer, get_message_counter());
msgpack_pack_int(packer, rbkit_message_field_payload);
msgpack_pack_array(packer, event->message_count);
sbuf->data = realloc(sbuf->data, event->buffer_size + sbuf->size);
memcpy(sbuf->data + sbuf->size, event->buffer, event->buffer_size);
sbuf->size += event->buffer_size;
}
static FilterReplyResult filter_apply(FilterReplyResultBase * const rb,
const struct sockaddr_storage * const sa_local,
const socklen_t sa_local_len,
struct msghdr *msg, size_t * const nbyte,
int * const flags)
{
msgpack_packer * const msgpack_packer = rb->filter->msgpack_packer;
if (rb->pre != false) {
filter_before_apply(rb, 2U, "recvmsg",
sa_local, sa_local_len, NULL, (socklen_t) 0U);
} else {
filter_before_apply(rb, 2U, "recvmsg",
sa_local, sa_local_len,
msg->msg_name, msg->msg_namelen);
}
msgpack_pack_mstring(msgpack_packer, "flags");
msgpack_pack_int(msgpack_packer, *flags);
if (rb->pre != false) {
msgpack_pack_mstring(msgpack_packer, "nbyte");
msgpack_pack_unsigned_long(msgpack_packer, *nbyte);
} else if (*rb->ret <= 0) {
msgpack_pack_mstring(msgpack_packer, "data");
msgpack_pack_nil(msgpack_packer);
} else {
assert((size_t) *rb->ret <= *nbyte);
msgpack_pack_mstring(msgpack_packer, "data");
msgpack_pack_raw(msgpack_packer, *nbyte);
size_t data_remaining = *nbyte;
size_t read_from_vec;
struct iovec * const vecs = msg->msg_iov;
size_t i_vecs = 0U;
while (i_vecs < (size_t) msg->msg_iovlen &&
data_remaining > (size_t) 0U) {
if (data_remaining < vecs[i_vecs].iov_len) {
read_from_vec = data_remaining;
} else {
read_from_vec = vecs[i_vecs].iov_len;
}
assert(data_remaining >= read_from_vec);
assert(vecs[i_vecs].iov_len >= read_from_vec);
msgpack_pack_raw_body(msgpack_packer, vecs[i_vecs].iov_base,
read_from_vec);
data_remaining -= read_from_vec;
i_vecs++;
}
}
if (filter_send_message(rb->filter) != 0) {
return FILTER_REPLY_RESULT_ERROR;
}
return filter_parse_reply(rb, msg, flags);
}
static inline void
pack_unsigned_integer(msgpack_packer *pk, const char *uint_token)
{
char *end;
unsigned long value;
errno = 0;
value = strtoul(uint_token, &end, 10);
/* TODO: error handling */
/* TODO */
msgpack_pack_unsigned_long(pk, value);
}
static void pack_object_space_dump_event(rbkit_object_space_dump_event *event, msgpack_packer *packer) {
size_t objects_in_batch;
size_t objects_left;
size_t count = 0;
size_t i = 0;
rbkit_object_dump_page *prev;
rbkit_object_data *data;
rbkit_object_dump_page * page;
msgpack_pack_map(packer, 5);
pack_event_header(packer, event->event_header.event_type);
// Incrementing integer holding the correlation_id
// indicating the event which the message belongs to
msgpack_pack_int(packer, rbkit_message_field_correlation_id);
msgpack_pack_int(packer, event->correlation_id);
// dump total number of messages in batch
msgpack_pack_int(packer, rbkit_message_field_complete_message_count);
msgpack_pack_unsigned_long(packer, event->object_count);
msgpack_pack_int(packer, rbkit_message_field_payload);
// Find the batch size
objects_in_batch = MAX_OBJECT_DUMPS_IN_MESSAGE ;
objects_left = event->object_count - event->packed_objects;
if(objects_left < MAX_OBJECT_DUMPS_IN_MESSAGE)
objects_in_batch = objects_left;
// Set size of array to hold all objects
msgpack_pack_array(packer, objects_in_batch);
// Iterate through all object data
while(count < objects_in_batch) {
if(event->current_page_index == RBKIT_OBJECT_DUMP_PAGE_SIZE) {
event->current_page_index = 0;
prev = event->current_page;
event->current_page = event->current_page->next;
free(prev);
}
page = event->current_page;
i = event->current_page_index;
data = &(page->data[i]);
/* Object dump is a map that looks like this :
* {
* object_id: <OBJECT_ID_IN_HEX>,
* class: <CLASS_NAME>,
* references: [<OBJECT_ID_IN_HEX>, <OBJECT_ID_IN_HEX>, ...],
* file: <FILE_PATH>,
* line: <LINE_NO>,
* size: <SIZE>
* }
*/
msgpack_pack_map(packer, 6);
// Key1 : rbkit_message_field_object_id
msgpack_pack_int(packer, rbkit_message_field_object_id);
// Value1 : pointer address of object
msgpack_pack_unsigned_long_long(packer, data->object_id);
// Key2 : rbkit_message_field_class_name
msgpack_pack_int(packer, rbkit_message_field_class_name);
// Value2 : Class name of object
pack_string(packer, data->class_name);
// Key3 : rbkit_message_field_references
msgpack_pack_int(packer, rbkit_message_field_references);
// Value3 : References held by the object
msgpack_pack_array(packer, data->reference_count);
if(data->reference_count != 0) {
size_t count = 0;
for(; count < data->reference_count; count++ )
msgpack_pack_unsigned_long_long(packer, data->references[count]);
free(data->references);
}
// Key4 : rbkit_message_field_file
msgpack_pack_int(packer, rbkit_message_field_file);
// Value4 : File path where object is defined
pack_string(packer, data->file);
// Key5 : rbkit_message_field_line
msgpack_pack_int(packer, rbkit_message_field_line);
// Value5 : Line no where object is defined
if(data->line == 0)
msgpack_pack_nil(packer);
else
msgpack_pack_unsigned_long(packer, data->line);
// Key6 : rbkit_message_field_size
msgpack_pack_int(packer, rbkit_message_field_size);
// Value6 : Size of the object in memory
if(data->size == 0)
msgpack_pack_nil(packer);
else
msgpack_pack_unsigned_long(packer, data->size);
event->current_page_index++;
event->packed_objects++;
count++;
}
}
static inline void
rbtrace__send_event(int nargs, const char *name, ...)
{
if (!rbtracer.attached_pid ||
!rbtracer.sbuf ||
!rbtracer.msgpacker ||
rbtracer.mqo_fd == -1)
return;
int n;
msgpack_sbuffer_clear(rbtracer.sbuf);
msgpack_packer *pk = rbtracer.msgpacker;
msgpack_pack_array(pk, nargs+1);
msgpack_pack_raw(pk, strlen(name));
msgpack_pack_raw_body(pk, name, strlen(name));
if (nargs > 0) {
int type;
int sint;
uint32_t uint;
uint64_t uint64;
unsigned long ulong;
char *str;
va_list ap;
va_start(ap, name);
for (n=0; n<nargs; n++) {
type = va_arg(ap, int);
switch (type) {
case 'b': // boolean
if (va_arg(ap, int))
msgpack_pack_true(pk);
else
msgpack_pack_false(pk);
break;
case 'd': // signed int
sint = va_arg(ap, int);
msgpack_pack_int(pk, sint);
break;
case 'u': // unsigned int
uint = va_arg(ap, uint32_t);
msgpack_pack_uint32(pk, uint);
break;
case 'l': // unsigned long (VALUE/ID)
ulong = va_arg(ap, unsigned long);
msgpack_pack_unsigned_long(pk, ulong);
break;
case 't': // uint64 (timestamps)
uint64 = va_arg(ap, uint64_t);
msgpack_pack_uint64(pk, uint64);
break;
case 'n': // current timestamp
msgpack_pack_uint64(pk, timeofday_usec());
break;
case 's': // string
str = va_arg(ap, char *);
if (!str)
str = (char *)"";
msgpack_pack_raw(pk, strlen(str));
msgpack_pack_raw_body(pk, str, strlen(str));
break;
default:
fprintf(stderr, "unknown type (%d) passed to rbtrace__send_event for %s\n", (int)type, name);
}
}
