Improvement: Message from babeltrace concerning discarded events needs improvement

New output example:

[warning] Tracer discarded 18508 events between [13:07:22.210641404] and [13:07:22.210642166] in trace UUID 857bd6395891954ab9d3defb2aeb98f7, at path: "/home/compudj/lttng-traces/auto-20130323-130705/kernel", within stream id 0, at relative path: "channel0_1". You should consider recording a new trace with larger buffers or with fewer events enabled.

Fixes #469

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

diff --git a/formats/ctf-text/ctf-text.c b/formats/ctf-text/ctf-text.c
index 0859378e01249e473292e1122577065efe990168..f60fde62f5fa794b749f91e0201fc92672f0a389 100644 (file)
--- a/formats/ctf-text/ctf-text.c
+++ b/formats/ctf-text/ctf-text.c
@@ -265,23 +265,7 @@ int ctf_text_write_event(struct bt_stream_pos *ppos, struct ctf_stream_definitio
        /* Print events discarded */
        if (stream->events_discarded) {
                fflush(pos->fp);
-               fprintf(stderr, "[warning] Tracer discarded %" PRIu64 " events between [",
-                       stream->events_discarded);
-               if (opt_clock_cycles) {
-                       ctf_print_timestamp(stderr, stream,
-                                       stream->prev_cycles_timestamp);
-                       fprintf(stderr, "] and [");
-                       ctf_print_timestamp(stderr, stream,
-                                       stream->prev_cycles_timestamp_end);
-               } else {
-                       ctf_print_timestamp(stderr, stream,
-                                       stream->prev_real_timestamp);
-                       fprintf(stderr, "] and [");
-                       ctf_print_timestamp(stderr, stream,
-                                       stream->prev_real_timestamp_end);
-               }
-               fprintf(stderr, "]. You should consider recording a new trace with larger buffers or with fewer events enabled.\n");
-               fflush(stderr);
+               ctf_print_discarded(stderr, stream);
                stream->events_discarded = 0;
        }
 

diff --git a/formats/ctf/ctf.c b/formats/ctf/ctf.c
index 7c1ef73535a199439dda21ae0f875da562932bc0..8f8af52517c407f1c32e80779f2fa35e69f717e1 100644 (file)
--- a/formats/ctf/ctf.c
+++ b/formats/ctf/ctf.c
@@ -391,6 +391,47 @@ void ctf_print_timestamp(FILE *fp,
        }
 }
 
+static
+void print_uuid(FILE *fp, unsigned char *uuid)
+{
+       int i;
+
+       for (i = 0; i < BABELTRACE_UUID_LEN; i++)
+               fprintf(fp, "%x", (unsigned int) uuid[i]);
+}
+
+void ctf_print_discarded(FILE *fp, struct ctf_stream_definition *stream)
+{
+       fprintf(fp, "[warning] Tracer discarded %" PRIu64 " events between [",
+               stream->events_discarded);
+       if (opt_clock_cycles) {
+               ctf_print_timestamp(fp, stream,
+                               stream->prev_cycles_timestamp);
+               fprintf(fp, "] and [");
+               ctf_print_timestamp(fp, stream,
+                               stream->prev_cycles_timestamp_end);
+       } else {
+               ctf_print_timestamp(fp, stream,
+                               stream->prev_real_timestamp);
+               fprintf(fp, "] and [");
+               ctf_print_timestamp(fp, stream,
+                               stream->prev_real_timestamp_end);
+       }
+       fprintf(fp, "] in trace UUID ");
+       print_uuid(fp, stream->stream_class->trace->uuid);
+       if (stream->stream_class->trace->path[0])
+               fprintf(fp, ", at path: \"%s\"",
+                       stream->stream_class->trace->path);
+
+       fprintf(fp, ", within stream id %" PRIu64, stream->stream_id);
+       if (stream->path[0])
+               fprintf(fp, ", at relative path: \"%s\"", stream->path);
+       fprintf(fp, ". ");
+       fprintf(fp, "You should consider recording a new trace with larger "
+               "buffers or with fewer events enabled.\n");
+       fflush(fp);
+}
+
 static
 int ctf_read_event(struct bt_stream_pos *ppos, struct ctf_stream_definition *stream)
 {
@@ -725,43 +766,24 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
                }
                if (pos->cur_index >= pos->packet_real_index->len) {
                        /*
-                        * When a stream reaches the end of the
-                        * file, we need to show the number of
-                        * events discarded ourselves, because
-                        * there is no next event scheduled to
-                        * be printed in the output.
+                        * We need to check if we are in trace read or
+                        * called from packet indexing.  In this last
+                        * case, the collection is not there, so we
+                        * cannot print the timestamps.
                         */
-                       if (file_stream->parent.events_discarded) {
+                       if ((&file_stream->parent)->stream_class->trace->collection) {
                                /*
-                                * We need to check if we are in trace
-                                * read or called from packet indexing.
-                                * In this last case, the collection is
-                                * not there, so we cannot print the
-                                * timestamps.
+                                * When a stream reaches the end of the
+                                * file, we need to show the number of
+                                * events discarded ourselves, because
+                                * there is no next event scheduled to
+                                * be printed in the output.
                                 */
-                               if ((&file_stream->parent)->stream_class->trace->collection) {
+                               if (file_stream->parent.events_discarded) {
                                        fflush(stdout);
-                                       fprintf(stderr, "[warning] Tracer discarded %" PRIu64 " events at end of stream between [",
-                                                       file_stream->parent.events_discarded);
-                                       if (opt_clock_cycles) {
-                                               ctf_print_timestamp(stderr,
-                                                               &file_stream->parent,
-                                                               file_stream->parent.prev_cycles_timestamp);
-                                               fprintf(stderr, "] and [");
-                                               ctf_print_timestamp(stderr, &file_stream->parent,
-                                                               file_stream->parent.prev_cycles_timestamp_end);
-                                       } else {
-                                               ctf_print_timestamp(stderr,
-                                                               &file_stream->parent,
-                                                               file_stream->parent.prev_real_timestamp);
-                                               fprintf(stderr, "] and [");
-                                               ctf_print_timestamp(stderr, &file_stream->parent,
-                                                               file_stream->parent.prev_real_timestamp_end);
-                                       }
-                                       fprintf(stderr, "]. You should consider recording a new trace with larger buffers or with fewer events enabled.\n");
-                                       fflush(stderr);
+                                       ctf_print_discarded(stderr, &file_stream->parent);
+                                       file_stream->parent.events_discarded = 0;
                                }
-                               file_stream->parent.events_discarded = 0;
                        }
                        pos->offset = EOF;
                        return;
@@ -1554,6 +1576,9 @@ int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags,
        file_stream = g_new0(struct ctf_file_stream, 1);
        file_stream->pos.last_offset = LAST_OFFSET_POISON;
 
+       strncpy(file_stream->parent.path, path, PATH_MAX);
+       file_stream->parent.path[PATH_MAX - 1] = '\0';
+
        if (packet_seek) {
                file_stream->pos.packet_seek = packet_seek;
        } else {

diff --git a/include/babeltrace/ctf-ir/metadata.h b/include/babeltrace/ctf-ir/metadata.h
index bc00015130b6ec0bdd57e938f3f63d9595051ea3..91df0362de445d9bd50bff82c08d1d2a9abb3694 100644 (file)
--- a/include/babeltrace/ctf-ir/metadata.h
+++ b/include/babeltrace/ctf-ir/metadata.h
@@ -66,6 +66,7 @@ struct ctf_stream_definition {
        uint64_t prev_real_timestamp_end;       /* End-of-last-packet timestamp in ns */
        uint64_t prev_cycles_timestamp;         /* Start-of-last-packet timestamp in cycles */
        uint64_t prev_cycles_timestamp_end;     /* End-of-last-packet timestamp in cycles */
+       char path[PATH_MAX];                    /* Path to stream. '\0' for mmap traces */
 };
 
 struct ctf_event_definition {

diff --git a/include/babeltrace/ctf/events-internal.h b/include/babeltrace/ctf/events-internal.h
index 0356906f3432eb6192bf13e997dfe1c6858a32d9..c7c28a1e0b60615009ed0ac49a4a09592e44af07 100644 (file)
--- a/include/babeltrace/ctf/events-internal.h
+++ b/include/babeltrace/ctf/events-internal.h
@@ -79,4 +79,6 @@ struct bt_ctf_iter {
        uint64_t events_lost;
 };
 
+void ctf_print_discarded(FILE *fp, struct ctf_stream_definition *stream);
+
 #endif /*_BABELTRACE_CTF_EVENTS_INTERNAL_H */