2019-02-15 14:24:29 +01:00
|
|
|
/****************************************************************************
|
2021-05-14 01:20:52 +02:00
|
|
|
* apps/examples/embedlog/embedlog_main.c
|
2019-02-15 14:24:29 +01:00
|
|
|
*
|
2021-05-14 01:20:52 +02:00
|
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
|
|
* this work for additional information regarding copyright ownership. The
|
|
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
|
|
* "License"); you may not use this file except in compliance with the
|
|
|
|
* License. You may obtain a copy of the License at
|
2019-02-15 14:24:29 +01:00
|
|
|
*
|
2021-05-14 01:20:52 +02:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2019-02-15 14:24:29 +01:00
|
|
|
*
|
2021-05-14 01:20:52 +02:00
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
|
|
* License for the specific language governing permissions and limitations
|
|
|
|
* under the License.
|
2019-02-15 14:24:29 +01:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Included Files
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-05-20 10:29:35 +02:00
|
|
|
#include <system/embedlog.h>
|
2019-02-15 14:24:29 +01:00
|
|
|
#include <errno.h>
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Preprocessor macros
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/* Macro used by OEL* macros, so we don't have to specify &g_el every time
|
|
|
|
* we want to print something.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define EL_OPTIONS_OBJECT &g_el
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Global variables
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/* Logger state, in flat build you need to create embedlog object and use it
|
|
|
|
* with el_o* functions. It is so, because embedlog defines one global object
|
|
|
|
* to make it easier to use embedlog on systems with MMU where each thread
|
|
|
|
* has it's own global memory. In nuttx in flat build that single object is
|
|
|
|
* shared between *all* tasks. You could probably get away with this if you
|
|
|
|
* use embedlog only in one task, but it's usually not the case. So in nuttx
|
|
|
|
* always create embedlog object. You can define EL_OPTIONS_OBJECT macro and
|
|
|
|
* use OEL* macros to make it almost as easy as using embedlog with global
|
|
|
|
* object. see el_options(3) to see learn more about it.
|
|
|
|
*/
|
|
|
|
|
2021-05-14 01:20:52 +02:00
|
|
|
static struct el g_el;
|
2019-02-15 14:24:29 +01:00
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: el_print_options
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Presents how to use options and how it's rendered. This assumes all
|
2020-05-20 10:29:35 +02:00
|
|
|
* options are enabled in compile time. If any of the options isn't enabled
|
2019-02-15 14:24:29 +01:00
|
|
|
* in compile time, setting it will have no effect and logs will vary.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static void el_print_options(void)
|
|
|
|
{
|
|
|
|
/* We will be printing logs to standard error output only */
|
|
|
|
|
|
|
|
el_ooption(&g_el, EL_OUT, EL_OUT_STDERR);
|
|
|
|
|
|
|
|
el_ooption(&g_el, EL_PRINT_LEVEL, 0);
|
|
|
|
el_oprint(OELI, "We can disable information about log level");
|
|
|
|
el_oprint(OELF, "message still will be filtered by log level");
|
|
|
|
el_oprint(OELA, "but there is no way to tell what level message is");
|
|
|
|
el_oprint(OELD, "like this message will not be printed");
|
|
|
|
|
|
|
|
el_ooption(&g_el, EL_TS, EL_TS_SHORT);
|
|
|
|
el_oprint(OELF, "As every respected logger, we also have timestamps");
|
|
|
|
el_oprint(OELF, "which work well with time from time()");
|
|
|
|
el_ooption(&g_el, EL_TS_TM, EL_TS_TM_MONOTONIC);
|
|
|
|
el_oprint(OELF, "or CLOCK_MONOTONIC from POSIX");
|
|
|
|
el_ooption(&g_el, EL_TS, EL_TS_LONG);
|
|
|
|
el_ooption(&g_el, EL_TS_TM, EL_TS_TM_TIME);
|
|
|
|
el_oprint(OELF, "we also have long format that works well with time()");
|
|
|
|
el_ooption(&g_el, EL_TS_TM, EL_TS_TM_REALTIME);
|
|
|
|
el_oprint(OELF, "if higher precision is needed we can use CLOCK_REALTIME");
|
|
|
|
el_ooption(&g_el, EL_TS, EL_TS_SHORT);
|
|
|
|
el_oprint(OELF, "we can also mix REALTIME with short format");
|
|
|
|
el_ooption(&g_el, EL_TS_FRACT, EL_TS_FRACT_OFF);
|
|
|
|
el_oprint(OELF, "and if you don't need high resolution");
|
|
|
|
el_oprint(OELF, "you can disable fractions of seconds to save space!");
|
|
|
|
el_ooption(&g_el, EL_TS_FRACT, EL_TS_FRACT_MS);
|
|
|
|
el_oprint(OELF, "or enable only millisecond resolution");
|
|
|
|
el_ooption(&g_el, EL_TS_FRACT, EL_TS_FRACT_US);
|
|
|
|
el_oprint(OELF, "or enable only microsecond resolution");
|
|
|
|
el_ooption(&g_el, EL_TS_FRACT, EL_TS_FRACT_NS);
|
|
|
|
el_oprint(OELF, "or enable only nanosecond resolution "
|
|
|
|
"(not that it makes much sense on nuttx)");
|
|
|
|
el_ooption(&g_el, EL_TS, EL_TS_LONG);
|
|
|
|
el_ooption(&g_el, EL_TS, EL_TS_OFF);
|
|
|
|
el_oprint(OELF, "no time information, if your heart desire it");
|
|
|
|
el_ooption(&g_el, EL_TS_FRACT, EL_TS_FRACT_NS);
|
|
|
|
|
|
|
|
el_ooption(&g_el, EL_FINFO, 1);
|
2019-11-08 14:52:22 +01:00
|
|
|
el_oprint(OELF, "log location is very useful for debugging");
|
2019-02-15 14:24:29 +01:00
|
|
|
|
|
|
|
el_ooption(&g_el, EL_TS, EL_TS_LONG);
|
|
|
|
el_ooption(&g_el, EL_TS_TM, EL_TS_TM_REALTIME);
|
|
|
|
el_ooption(&g_el, EL_PRINT_LEVEL, 1);
|
|
|
|
el_oprint(OELF, "Different scenarios need different options");
|
|
|
|
el_oprint(OELA, "So we can mix options however we want");
|
|
|
|
|
|
|
|
el_ooption(&g_el, EL_PRINT_NL, 0);
|
|
|
|
el_oprint(OELF, "you can also remove printing new line ");
|
|
|
|
el_oputs(&g_el, "to join el_oprint and el_oputs in a single ");
|
|
|
|
el_oputs(&g_el, "long line as needed\n");
|
|
|
|
el_ooption(&g_el, EL_PRINT_NL, 1);
|
|
|
|
|
|
|
|
el_ooption(&g_el, EL_COLORS, 1);
|
|
|
|
el_ooption(&g_el, EL_LEVEL, EL_DBG);
|
|
|
|
el_oprint(OELD, "And if we have");
|
|
|
|
el_oprint(OELI, "modern terminal");
|
|
|
|
el_oprint(OELN, "we can enable colors");
|
|
|
|
el_oprint(OELW, "to spot warnings");
|
|
|
|
el_oprint(OELE, "or errors");
|
|
|
|
el_oprint(OELC, "with a quick");
|
|
|
|
el_oprint(OELA, "glance into");
|
|
|
|
el_oprint(OELF, "log file");
|
|
|
|
|
|
|
|
el_ooption(&g_el, EL_PREFIX, "embedlog: ");
|
|
|
|
el_oprint(OELI, "you can also use prefixes");
|
|
|
|
el_oprint(OELI, "to every message you send");
|
|
|
|
|
|
|
|
el_ooption(&g_el, EL_PREFIX, NULL);
|
|
|
|
el_oprint(OELI, "set prefix to null to disable it");
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: el_print_memory
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Presents how to print blob of memory.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static void el_print_memory(void)
|
|
|
|
{
|
|
|
|
char s[] = "some message\0that contains\0null characters";
|
|
|
|
char ascii[128];
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i != 128; ++i)
|
|
|
|
{
|
|
|
|
ascii[i] = (char)i;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We will be printing logs to standard error output only */
|
|
|
|
|
|
|
|
el_ooption(&g_el, EL_OUT, EL_OUT_STDERR);
|
|
|
|
|
|
|
|
el_oprint(OELI, "print whole ASCII table");
|
|
|
|
el_opmemory(OELI, ascii, sizeof(ascii));
|
|
|
|
|
2019-11-08 14:52:22 +01:00
|
|
|
el_oprint(OELI, "print memory region that contains string with NULL "
|
|
|
|
"chars");
|
2019-02-15 14:24:29 +01:00
|
|
|
el_opmemory(OELI, s, sizeof(s));
|
|
|
|
|
2019-11-08 14:52:22 +01:00
|
|
|
el_oprint(OELI, "print the same region but this time with nice ascii "
|
|
|
|
"table");
|
2019-02-15 14:24:29 +01:00
|
|
|
el_opmemory_table(OELI, s, sizeof(s));
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: el_print_file
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Presents how to print data to file with log rotation
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* workdir - directory where logs will be stored.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static void el_print_file(const char *workdir)
|
|
|
|
{
|
|
|
|
char log_path[PATH_MAX];
|
|
|
|
|
|
|
|
/* create user specified directory if it doesn't exist */
|
|
|
|
|
|
|
|
if (mkdir(workdir, 0755) != 0 && errno != EEXIST)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "Couldn't create %s, error %s\n",
|
|
|
|
workdir, strerror(errno));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create full path to log file embedlog will use */
|
|
|
|
|
|
|
|
sprintf(log_path, "%s/log-rotate", workdir);
|
|
|
|
|
|
|
|
/* Enable file rotation, maximum 5 files will be created, none of the log
|
|
|
|
* files size shall exceed 512 bytes. Rotate size is low to present how
|
|
|
|
* rotation works, in real life this should be much higher, unless you
|
|
|
|
* really know what you are doing and understand the consequences of low
|
|
|
|
* rotate size.
|
|
|
|
*/
|
|
|
|
|
|
|
|
el_ooption(&g_el, EL_FROTATE_NUMBER, 5);
|
|
|
|
el_ooption(&g_el, EL_FROTATE_SIZE, 512);
|
|
|
|
|
|
|
|
/* Tell embedlog to sync all buffers and metadata regarding log file.
|
|
|
|
* There are cases, when data (a lot of data) goes into block device,
|
|
|
|
* but metadata of the file are not updated when power loss occurs. This
|
|
|
|
* leads to data loss - even though they landed physically on block device
|
|
|
|
* like sdcard. To prevent losing too much data, you can define how often
|
|
|
|
* you want embedlog to call sync() functions. It basically translates to
|
|
|
|
* "how much data am I ready to loose?". In this example, we sync() once
|
|
|
|
* every 4096 bytes are stored into file.
|
|
|
|
*/
|
|
|
|
|
|
|
|
el_ooption(&g_el, EL_FILE_SYNC_EVERY, 4096);
|
|
|
|
|
|
|
|
/* Setting above value to too small value, will cause sync() to be called
|
|
|
|
* very often (depending on how much data you log) and that may criple
|
|
|
|
* performance greatly. And there are situations when you are willing to
|
|
|
|
* loose some info or debug data (up to configured sync every value), but
|
|
|
|
* when critical error shows up, you want data to be synced immediately to
|
2020-02-22 19:52:12 +01:00
|
|
|
* minimize chance of losing information about critical error. For that
|
2019-02-15 14:24:29 +01:00
|
|
|
* you can define which log level will be synced *every* time regardless
|
|
|
|
* of sync every value. Here we will instruct embedlog to log prints that
|
|
|
|
* have severity higher or equal to critical (so critial, alert and fatal)
|
|
|
|
*/
|
|
|
|
|
|
|
|
el_ooption(&g_el, EL_FILE_SYNC_LEVEL, EL_CRIT);
|
|
|
|
|
|
|
|
/* Print logs to both file and standard error */
|
|
|
|
|
|
|
|
el_ooption(&g_el, EL_OUT, EL_OUT_FILE | EL_OUT_STDERR);
|
|
|
|
|
|
|
|
/* Register path to log file in embedlog. This will cause logger to look
|
|
|
|
* for next valid log file (when log rotate in enabled) and will try to
|
|
|
|
* open file for reading.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (el_ooption(&g_el, EL_FPATH, log_path) != 0)
|
|
|
|
{
|
|
|
|
if (errno == ENAMETOOLONG || errno == EINVAL)
|
|
|
|
{
|
2020-05-20 10:29:35 +02:00
|
|
|
/* These are the only unrecoverable errors embedlog may return,
|
2019-02-15 14:24:29 +01:00
|
|
|
* any other error it actually a warning, telling user that file
|
|
|
|
* could not have been opened now, but every el_print function with
|
|
|
|
* output to file enabled, will try to reopen file. This of course
|
2019-11-08 14:52:22 +01:00
|
|
|
* apply to situation when problem is temporary - like directory
|
|
|
|
* does not exist but will be created after warning, or file has
|
|
|
|
* no write permission but it gets fixed later.
|
2019-02-15 14:24:29 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
fprintf(stderr, "log file name too long");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(stderr, "WARNING: couldn't open file: %s\n", strerror(errno));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now we can print messages */
|
|
|
|
|
|
|
|
el_oprint(OELI, "Now we enabled log rotation");
|
|
|
|
el_oprint(OELI, "If log cannot fit in current file");
|
2020-05-20 10:29:35 +02:00
|
|
|
el_oprint(OELI, "it will be stored in new file and");
|
|
|
|
el_oprint(OELI, "if library creates EL_FROTATE_NUMBER files oldest");
|
|
|
|
el_oprint(OELI, "file will be deleted and new file will be created");
|
2019-02-15 14:24:29 +01:00
|
|
|
el_oprint(OELI, "run this program multiple times and see how it works");
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Public Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* embedlog_main
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
int main(int argc, FAR char *argv[])
|
|
|
|
{
|
|
|
|
if (argc > 2 || (argc == 2 && strcmp(argv[1], "-h") == 0))
|
|
|
|
{
|
|
|
|
fprintf(stderr, "usage: %s [<log-directory>]\n", argv[0]);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize embedlog object to sane and known values */
|
|
|
|
|
|
|
|
el_oinit(&g_el);
|
|
|
|
|
2020-05-20 10:29:35 +02:00
|
|
|
el_oprint(OELI, "Right after init, embedlog will print to stderr with "
|
|
|
|
"just log level information - these are default settings.");
|
2019-02-15 14:24:29 +01:00
|
|
|
|
|
|
|
el_print_options();
|
|
|
|
el_print_memory();
|
|
|
|
|
|
|
|
if (argc == 2)
|
|
|
|
{
|
|
|
|
el_print_file(argv[1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This will cleanup whatever has been allocated by el_oinit(), like opened
|
|
|
|
* file descriptors
|
|
|
|
*/
|
|
|
|
|
|
|
|
el_ocleanup(&g_el);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|