Index

lognestmonster / 2da0fcd

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?
14324 Nov 2019 20:412da0fcdRegistry controlsJosh Stockin14619N

Blob @ lognestmonster / src / c / lognestmonster.h

text/plain10415 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
94
95// Statement and event structure definitions
96
97typedef struct {
98 uint8_t type:1; // Used internally; 0 = statement, 1 = event
99 uint8_t boolpushed:1; // whether or not this log item has been pushed
100 lnm_pushable * pushed; // array of memory locations for lnm_log_event and lnm_log_statement structs
101} lnm_log_event;
102
103typedef struct {
104 // word 1, 4 bytes data 4 bytes padding
105 uint8_t type:1; // Used internally; 0 = statement, 1 = event
106 uint8_t boolpushed:1; // whether or not this log item has been pushed
107 uint8_t verbosity:3; // lnmVerbosityLevel, 0-5
108 uint8_t tag_size; // character length of the tag
109 uint16_t message_size; // character length of the message
110
111 // word 2, 8 bytes data
112 uint64_t timestamp; // 64-bit millisecond timestamp
113
114 // word 3, 8 bytes data
115 char * log; // tag string + message string
116} lnm_log_statement;
117
118
119// Queue structure definition
120
121typedef struct {
122 char * name;
123 char * out_path;
124 uint64_t timestamp;
125 lnm_pushable * pushed;
126} lnm_queue;
127
128
129// Library utilities
130
131unsigned long lnm_getus(void) {
132 struct timeval current_time;
133 gettimeofday(&current_time, NULL);
134 unsigned long ms = (current_time.tv_sec*1000000+current_time.tv_usec);
135 return ms;
136}
137
138unsigned long lnm_getms(void) {
139 return lnm_getus()/1000;
140}
141
142
143int lnm_isstatement(lnmItem item) {
144 lnm_log_statement * s = (lnm_log_statement *)item;
145 return !s->type;
146}
147
148
149// Item registry utils
150
151lnm_pushable * lnm_registered_queues;
152lnm_pushable * lnm_registered_items;
153
154int lnm_treescan_match(lnmItem toscan, lnmItem match) {
155 return 0;
156}
157
158void lnm_registry_update(void) { // scan each registered item
159 for (int iter = 0; iter < lnm_registered_items->length; iter++) {
160 lnm_log_statement * s = (lnm_log_statement *)lnm_registered_items->pushed[iter];
161 if (s->boolpushed == 1) { // if the registered item has been pushed elsewhere, remove it from the top level of the registry
162 lnm_pushable_remove(lnm_registered_items, iter);
163 iter--;
164 }
165 }
166}
167
168
169// Core library
170
171lnmQueue lnmQueueInit(char * name, char * out_path) {
172 if (lnm_registered_queues == NULL) {
173 lnm_registered_queues = lnm_new_pushable();
174 }
175 if (lnm_registered_items == NULL) {
176 lnm_registered_items = lnm_new_pushable();
177 }
178
179 lnm_queue * new_queue = malloc(sizeof(lnm_queue));
180 new_queue->name = malloc(strlen(name)+1);
181 new_queue->out_path = malloc(strlen(out_path)+1);
182 strcpy(new_queue->name, name);
183 strcpy(new_queue->out_path, out_path);
184 new_queue->pushed = lnm_new_pushable();
185
186 lnm_pushable_push(lnm_registered_queues, (lnmQueue)new_queue);
187 return (lnmQueue)new_queue;
188}
189
190lnmQueue lnmQueueByName(char * name) {
191 if (lnm_registered_queues == NULL) {
192 printf("lognestmonster (lnmQueueByName): queue registry is nonexistant. exiting...\n");
193 exit(1);
194 }
195 if (lnm_registered_queues->length == 0) {
196 printf("lognestmonster (lnmQueueByName): queue registry is empty. exiting...\n");
197 exit(1);
198 }
199 for (int iter = 0; iter<lnm_registered_queues->length; iter++) {
200 lnm_queue * iterqueue = (lnm_queue *)lnm_registered_queues->pushed[iter];
201 if (strcmp(iterqueue->name, name)==0) {
202 return (lnmQueue)iterqueue;
203 }
204 }
205 printf("lognestmonster (lnmQueueByName): queue not found in registry. exiting...\n");
206 exit(1);
207}
208
209
210lnmItem lnmStatement(uint8_t verbosity, char * tag, char * message) {
211 lnm_log_statement * new_statement = malloc(sizeof(lnm_log_statement));
212 new_statement->type = 0;
213 new_statement->verbosity = verbosity;
214 new_statement->timestamp = lnm_getus();
215 int tlen = strlen(tag);
216 if (tlen > 255 || tlen < 0) {
217 printf("lognestmonster (lnmStatement): tag length %i is longer than the cap 255 characters. exiting...\n", tlen);
218 exit(1);
219 }
220 int mlen = strlen(message);
221 if (mlen > 65535 || mlen < 0) {
222 printf("lognestmonster (lnmStatement): message length %i is longer than the cap 65535 characters. exiting...\n", mlen);
223 exit(1);
224 }
225 new_statement->tag_size = tlen;
226 new_statement->message_size = mlen;
227 new_statement->log = malloc(tlen+mlen+1);
228 strcpy(new_statement->log, tag);
229 strcat(new_statement->log, message);
230 lnm_registry_update();
231 lnm_pushable_push(lnm_registered_items, new_statement);
232 return (lnmItem)new_statement;
233}
234
235
236lnmItem lnmEvent(void) {
237 lnm_log_event * new_event = malloc(sizeof(lnm_log_event));
238 new_event->type = 1;
239 new_event->pushed = lnm_new_pushable();
240 lnm_registry_update();
241 lnm_pushable_push(lnm_registered_items, new_event);
242 return (lnmItem)new_event;
243}
244
245void lnmEventPush(lnmItem event, lnmItem item) {
246 if (event == item) {
247 printf("lognestmonster (lnmEventPush): attempt to push event to self. exiting...\n");
248 exit(1);
249 }
250 lnm_log_statement * item_cast = (lnm_log_statement *)item;
251 if (item_cast->boolpushed == 1) {
252 printf("lognestmonster (lnmEventPush): attempt to push an already-pushed log item. exiting...\n");
253 exit(1);
254 }
255 lnm_log_event * event_t = (lnm_log_event *)event;
256 if (event_t->type != 1) {
257 printf("lognestmonster (lnmEventPush): cannot cast non-event to event type. exiting...\n");
258 exit(1);
259 }
260 lnm_pushable_push(event_t->pushed, item);
261 item_cast->boolpushed = 1;
262 lnm_registry_update();
263}
264
265void lnmEventPushS(lnmItem event, uint8_t verbosity, char * tag, char * message) {
266 lnmItem statement = lnmStatement(verbosity, tag, message);
267 lnmEventPush(event, statement);
268}
269
270lnmItem lnmEventI(lnmItem item) {
271 lnmItem event = lnmEvent();
272 lnmEventPush(event, item);
273 return event;
274}
275
276lnmItem lnmEventS(uint8_t verbosity, char * tag, char * message) {
277 lnmItem statement = lnmStatement(verbosity, tag, message);
278 return lnmEventI(statement);
279}
280
281
282void lnm_debug_tabs(int count) {
283 for (int i = 0; i < count; i++) {
284 printf(" ");
285 }
286}
287
288void lnm_debug_parse_registry() {
289 printf("Top level registry (%i) {\n", lnm_registered_items->length);
290 for (int iter = 0; iter < lnm_registered_items->length; iter++) {
291 lnm_debug_parse_item(lnm_registered_items->pushed[iter], 1);
292 }
293 printf("}\n");
294}
295
296void lnm_debug_parse_item(lnmItem item, int tabcount) {
297 if (lnm_isstatement(item)) {
298 lnm_log_statement * statement = (lnm_log_statement *) item;
299 lnm_debug_tabs(tabcount);
300 printf("Statement {\n");
301
302 lnm_debug_tabs(tabcount+1);
303 char * verbosity;
304 switch (statement->verbosity) {
305 case 0:
306 verbosity = "INFO";
307 break;
308 case 1:
309 verbosity = "DEBUG";
310 break;
311 case 2:
312 verbosity = "VERBOSE";
313 break;
314 case 3:
315 verbosity = "VERYVERBOSE";
316 break;
317 case 4:
318 verbosity = "WARNING";
319 break;
320 case 5:
321 verbosity = "ERROR";
322 break;
323 }
324 printf("Verbosity %s\n", verbosity);
325
326 lnm_debug_tabs(tabcount+1);
327 printf("Timestamp %ld\n", statement->timestamp);
328
329 lnm_debug_tabs(tabcount+1);
330 char tag[statement->tag_size+1];
331 strncpy(tag, statement->log, statement->tag_size);
332 tag[statement->tag_size] = '\0';
333 printf("Tag (%i) %s\n", statement->tag_size, tag);
334
335 lnm_debug_tabs(tabcount+1);
336 char message[statement->message_size+1];
337 strncpy(message, statement->log+statement->tag_size, statement->message_size);
338 message[statement->message_size] = '\0';
339 printf("Message (%i) %s\n", statement->message_size, message);
340
341 lnm_debug_tabs(tabcount);
342 printf("}\n");
343 } else if (!lnm_isstatement(item)) {
344 lnm_log_event * event = (lnm_log_event *) item;
345 lnm_debug_tabs(tabcount);
346 printf("Event (%i) [\n", event->pushed->length);
347 for (int i = 0; i < event->pushed->length; i++) {
348 lnmItem item = event->pushed->pushed[i];
349 lnm_debug_parse_item(item, tabcount + 1);
350 }
351 lnm_debug_tabs(tabcount);
352 printf("]\n");
353 } else {
354 printf("lognestmonster (lnm_debug_parse_item): unknown item type. exiting...\n");
355 exit(1);
356 }
357}
358
359#endif
360