Index

lognestmonster / 9d96bcb

A general-purpose single-header C logging library and parser for event-based logs. (Incomplete)

Download | Refs | Commit Log | Files | README | LICENSE

Latest Commit

{#}TimeHashSubjectAuthor#(+)(-)GPG?
14725 Nov 2019 19:429d96bcbRegistry/item memory managementJosh Stockin1380N

Blob @ lognestmonster / src / c / lognestmonster.h

text/plain11476 bytesdownload raw
1// lognestmonster Copyright (c) 2019 Joshua 'joshuas3' Stockin
2// lognestmonster.h
3// C header file for implementation of the lognestmonster logging library
4
5// <https://github.com/JoshuaS3/lognestmonster/>.
6
7
8// This file is part of lognestmonster.
9
10// lognestmonster is free software: you can redistribute it and/or modify
11// it under the terms of the GNU General Public License as published by
12// the Free Software Foundation, either version 3 of the License, or
13// (at your option) any later version.
14
15// lognestmonster is distributed in the hope that it will be useful,
16// but WITHOUT ANY WARRANTY; without even the implied warranty of
17// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18// GNU General Public License for more details.
19
20// You should have received a copy of the GNU General Public License
21// along with lognestmonster. If not, see <https://www.gnu.org/licenses/>.
22
23#ifndef __LOGNESTMONSTER__
24#define __LOGNESTMONSTER__ 1
25
26// SEMANTICS
27// internal definitions: lnm_lower_camel_case
28// public definitions: lnmUpperCamelCase
29
30// stdc inclusions
31
32#include <stdint.h>
33#include <stdlib.h>
34#include <string.h>
35#include <sys/time.h>
36
37
38// Base definitions
39
40enum lnmVerbosityLevel {lnmInfo, lnmDebug, lnmVerbose, lnmVeryVerbose, lnmWarning, lnmError};
41typedef uint8_t * lnmItem;
42typedef uint8_t * lnmQueue;
43
44
45// Pushable structure
46
47typedef struct {
48 uint16_t length;
49 lnmItem * pushed;
50} lnm_pushable;
51
52lnm_pushable * lnm_new_pushable() {
53 lnm_pushable * new_pushable = malloc(sizeof(lnm_pushable));
54 new_pushable->length = 0;
55 new_pushable->pushed = malloc(0);
56 return new_pushable;
57}
58
59void lnm_pushable_push(lnm_pushable * pushable, lnmItem item) {
60 if (pushable->length+1 >= 65535) {
61 printf("lognestmonster (lnm_pushable_push): pushable reached cap length 65535. exiting...\n");
62 exit(1);
63 }
64 pushable->pushed = realloc(pushable->pushed, sizeof(lnmItem)*(pushable->length+1)); // reallocate with size: length+1
65 pushable->pushed[pushable->length] = item;
66 pushable->length += 1;
67}
68
69int lnm_pushable_indexof(lnm_pushable * pushable, lnmItem item) {
70 int len = pushable->length;
71 for (int iter = 0; iter<len; iter++) {
72 if (item == pushable->pushed[iter]) return iter;
73 }
74 return -1;
75}
76
77void lnm_pushable_remove(lnm_pushable * pushable, int index) {
78 if (index>=pushable->length || index < 0) {
79 printf("lognestmonster (lnm_pushable_remove): attempt to remove index out of pushable bounds. exiting...\n");
80 exit(1);
81 }
82 lnmItem * new_pushed = malloc(sizeof(lnmItem)*(pushable->length-1)); // map array excluding index
83 for (int iter = 0; iter<index; iter++) {
84 new_pushed[iter] = pushable->pushed[iter];
85 }
86 for (int iter = index+1; iter<pushable->length; iter++) {
87 new_pushed[iter-1] = pushable->pushed[iter];
88 }
89 free(pushable->pushed);
90 pushable->length--;
91 pushable->pushed = new_pushed;
92}
93
94void lnm_pushable_free(lnm_pushable * pushable) {
95 free(pushable->pushed);
96 free(pushable);
97}
98
99
100// Statement and event structure definitions
101
102typedef struct {
103 uint8_t type:1; // Used internally; 0 = statement, 1 = event
104 uint8_t boolpushed:1; // whether or not this log item has been pushed
105 lnm_pushable * pushed; // array of memory locations for lnm_log_event and lnm_log_statement structs
106} lnm_log_event;
107
108typedef struct {
109 // word 1, 4 bytes data 4 bytes padding
110 uint8_t type:1; // Used internally; 0 = statement, 1 = event
111 uint8_t boolpushed:1; // whether or not this log item has been pushed
112 uint8_t verbosity:3; // lnmVerbosityLevel, 0-5
113 uint8_t tag_size; // character length of the tag
114 uint16_t message_size; // character length of the message
115
116 // word 2, 8 bytes data
117 uint64_t timestamp; // 64-bit millisecond timestamp
118
119 // word 3, 8 bytes data
120 char * log; // tag string + message string
121} lnm_log_statement;
122
123
124// Queue structure definition
125
126typedef struct {
127 char * name;
128 char * out_path;
129 uint64_t timestamp;
130 lnm_pushable * pushed;
131} lnm_queue;
132
133
134// Library utilities
135
136unsigned long lnm_getus(void) {
137 struct timeval current_time;
138 gettimeofday(&current_time, NULL);
139 unsigned long ms = (current_time.tv_sec*1000000+current_time.tv_usec);
140 return ms;
141}
142
143unsigned long lnm_getms(void) {
144 return lnm_getus()/1000;
145}
146
147
148int lnm_isstatement(lnmItem item) {
149 lnm_log_statement * s = (lnm_log_statement *)item;
150 return !s->type;
151}
152
153
154// Item registry utils
155
156lnm_pushable * lnm_registered_queues;
157lnm_pushable * lnm_registered_items;
158static int lnm_registry_update_count;
159
160void lnm_registry_update(void) { // scan each registered item
161 for (int iter = 0; iter < lnm_registered_items->length; iter++) {
162 lnm_log_statement * s = (lnm_log_statement *)lnm_registered_items->pushed[iter];
163 if (s->boolpushed == 1) { // if the registered item has been pushed elsewhere, remove it from the top level of the registry
164 lnm_registry_update_count++;
165 lnm_pushable_remove(lnm_registered_items, iter);
166 iter--;
167 }
168 }
169}
170
171
172// Core library
173
174void lnm_free_item(lnmItem item) {
175 lnm_log_statement * item_cast = (lnm_log_statement *)item;
176 if (item_cast->type == 0) {
177 item_cast->boolpushed = 1; // flush item out of the registry
178 lnm_registry_update();
179
180 free(item_cast->log);
181 free(item_cast);
182 } else if (item_cast->type == 1) {
183 lnm_log_event * event_cast = (lnm_log_event *)item_cast;
184 event_cast->boolpushed = 1; // flush item out of the registry
185 lnm_registry_update();
186
187 for (int iter = 0; iter < event_cast->pushed->length; iter++) { // free logtree children
188 lnmItem newitem = event_cast->pushed->pushed[iter];
189 lnm_free_item(newitem);
190 }
191 lnm_pushable_free(event_cast->pushed);
192 free(event_cast);
193 } else {
194 printf("lognestmonster (lnm_free_item): non-log item passed to function. exiting...\n");
195 }
196}
197
198void lnm_free_registry() {
199 for (int iter = 0; iter < lnm_registered_items->length; iter++) {
200 lnm_free_item(lnm_registered_items->pushed[iter]);
201 }
202}
203
204
205lnmQueue lnmQueueInit(char * name, char * out_path) {
206 if (lnm_registered_queues == NULL) {
207 lnm_registered_queues = lnm_new_pushable();
208 }
209 if (lnm_registered_items == NULL) {
210 lnm_registered_items = lnm_new_pushable();
211 }
212
213 lnm_queue * new_queue = malloc(sizeof(lnm_queue));
214 new_queue->name = malloc(strlen(name)+1);
215 new_queue->out_path = malloc(strlen(out_path)+1);
216 strcpy(new_queue->name, name);
217 strcpy(new_queue->out_path, out_path);
218 new_queue->pushed = lnm_new_pushable();
219
220 lnm_pushable_push(lnm_registered_queues, (lnmQueue)new_queue);
221 return (lnmQueue)new_queue;
222}
223
224lnmQueue lnmQueueByName(char * name) {
225 if (lnm_registered_queues == NULL) {
226 printf("lognestmonster (lnmQueueByName): queue registry is nonexistant. exiting...\n");
227 exit(1);
228 }
229 if (lnm_registered_queues->length == 0) {
230 printf("lognestmonster (lnmQueueByName): queue registry is empty. exiting...\n");
231 exit(1);
232 }
233 for (int iter = 0; iter<lnm_registered_queues->length; iter++) {
234 lnm_queue * iterqueue = (lnm_queue *)lnm_registered_queues->pushed[iter];
235 if (strcmp(iterqueue->name, name)==0) {
236 return (lnmQueue)iterqueue;
237 }
238 }
239 printf("lognestmonster (lnmQueueByName): queue not found in registry. exiting...\n");
240 exit(1);
241}
242
243
244lnmItem lnmStatement(uint8_t verbosity, char * tag, char * message) {
245 lnm_log_statement * new_statement = malloc(sizeof(lnm_log_statement));
246 new_statement->type = 0;
247 new_statement->verbosity = verbosity;
248 new_statement->timestamp = lnm_getus();
249 int tlen = strlen(tag);
250 if (tlen > 255 || tlen < 0) {
251 printf("lognestmonster (lnmStatement): tag length %i is longer than the cap 255 characters. exiting...\n", tlen);
252 exit(1);
253 }
254 int mlen = strlen(message);
255 if (mlen > 65535 || mlen < 0) {
256 printf("lognestmonster (lnmStatement): message length %i is longer than the cap 65535 characters. exiting...\n", mlen);
257 exit(1);
258 }
259 new_statement->tag_size = tlen;
260 new_statement->message_size = mlen;
261 new_statement->log = malloc(tlen+mlen+1);
262 strcpy(new_statement->log, tag);
263 strcat(new_statement->log, message);
264 lnm_registry_update();
265 lnm_pushable_push(lnm_registered_items, (lnmItem)new_statement);
266 return (lnmItem)new_statement;
267}
268
269
270lnmItem lnmEvent(void) {
271 lnm_log_event * new_event = malloc(sizeof(lnm_log_event));
272 new_event->type = 1;
273 new_event->pushed = lnm_new_pushable();
274 lnm_registry_update();
275 lnm_pushable_push(lnm_registered_items, (lnmItem)new_event);
276 return (lnmItem)new_event;
277}
278
279void lnmEventPush(lnmItem event, lnmItem item) {
280 if (event == item) {
281 printf("lognestmonster (lnmEventPush): attempt to push event to self. exiting...\n");
282 exit(1);
283 }
284 lnm_log_statement * item_cast = (lnm_log_statement *)item;
285 if (item_cast->boolpushed == 1) {
286 printf("lognestmonster (lnmEventPush): attempt to push an already-pushed log item. exiting...\n");
287 exit(1);
288 }
289 lnm_log_event * event_t = (lnm_log_event *)event;
290 if (event_t->type != 1) {
291 printf("lognestmonster (lnmEventPush): cannot cast non-event to event type. exiting...\n");
292 exit(1);
293 }
294 lnm_pushable_push(event_t->pushed, item);
295 item_cast->boolpushed = 1;
296 lnm_registry_update();
297}
298
299void lnmEventPushS(lnmItem event, uint8_t verbosity, char * tag, char * message) {
300 lnmItem statement = lnmStatement(verbosity, tag, message);
301 lnmEventPush(event, statement);
302}
303
304lnmItem lnmEventI(lnmItem item) {
305 lnmItem event = lnmEvent();
306 lnmEventPush(event, item);
307 return event;
308}
309
310lnmItem lnmEventS(uint8_t verbosity, char * tag, char * message) {
311 lnmItem statement = lnmStatement(verbosity, tag, message);
312 return lnmEventI(statement);
313}
314
315
316void lnm_debug_tabs(int count) {
317 for (int i = 0; i < count; i++) {
318 printf(" ");
319 }
320}
321
322void lnm_debug_parse_item(lnmItem item, int tabcount) {
323 if (lnm_isstatement(item)) {
324 lnm_log_statement * statement = (lnm_log_statement *) item;
325 lnm_debug_tabs(tabcount);
326 printf("Statement {\n");
327
328 lnm_debug_tabs(tabcount+1);
329 char * verbosity;
330 switch (statement->verbosity) {
331 case 0:
332 verbosity = "INFO";
333 break;
334 case 1:
335 verbosity = "DEBUG";
336 break;
337 case 2:
338 verbosity = "VERBOSE";
339 break;
340 case 3:
341 verbosity = "VERYVERBOSE";
342 break;
343 case 4:
344 verbosity = "WARNING";
345 break;
346 case 5:
347 verbosity = "ERROR";
348 break;
349 }
350 printf("Verbosity %s\n", verbosity);
351
352 lnm_debug_tabs(tabcount+1);
353 printf("Timestamp %ld\n", statement->timestamp);
354
355 lnm_debug_tabs(tabcount+1);
356 char tag[statement->tag_size+1];
357 strncpy(tag, statement->log, statement->tag_size);
358 tag[statement->tag_size] = '\0';
359 printf("Tag (%i) \"%s\"\n", statement->tag_size, tag);
360
361 lnm_debug_tabs(tabcount+1);
362 char message[statement->message_size+1];
363 strncpy(message, statement->log+statement->tag_size, statement->message_size);
364 message[statement->message_size] = '\0';
365 printf("Message (%i) \"%s\"\n", statement->message_size, message);
366
367 lnm_debug_tabs(tabcount);
368 printf("}\n");
369 } else if (!lnm_isstatement(item)) {
370 lnm_log_event * event = (lnm_log_event *) item;
371 lnm_debug_tabs(tabcount);
372 printf("Event (%i) [\n", event->pushed->length);
373 for (int i = 0; i < event->pushed->length; i++) {
374 lnmItem item = event->pushed->pushed[i];
375 lnm_debug_parse_item(item, tabcount + 1);
376 }
377 lnm_debug_tabs(tabcount);
378 printf("]\n");
379 } else {
380 printf("lognestmonster (lnm_debug_parse_item): unknown item type. exiting...\n");
381 exit(1);
382 }
383}
384
385void lnm_debug_parse_registry() {
386 printf("Top level registry (%i) {\n", lnm_registered_items->length);
387 for (int iter = 0; iter < lnm_registered_items->length; iter++) {
388 lnm_debug_parse_item(lnm_registered_items->pushed[iter], 1);
389 }
390 printf("}\n");
391}
392
393#endif
394