amos-logging-service
v12.0.4
Published
Logging functionalities for apps built with Ionic framework
Downloads
6
Maintainers
Readme
ionic-logging-service
The dependencies used by the latest version are the same as needed for Ionic 5.0.0. For older versions use:
| ionic-logging-service | Ionic | Angular | ------ | -------- | ------ | 13.0.0 | >= 5.0.0 | ^12.0.0 | 12.0.0 | >= 5.0.0 | ^11.0.0 | 11.0.0 | >= 5.0.0 | ^10.0.0 | 9.0.0 | >= 5.0.0 | ^9.0.0 | 8.0.0 | >= 4.7.0 | ^8.0.0 | 7.0.0 | >= 4.0.0-rc | ^7.0.0 | 6.0.0 | >= 4.0.0-beta | ^6.0.0 | 5.1.0 | >= 3.9.0 | ^5.0.0 | 3.1.0 | >= 3.0.0 | ^4.0.0 | 2.0.0 | >= 2.2.0 | ^2.4.8 | 1.2.1 | >= 2.0.0 | ^2.2.1
This service encapsulates log4javascript's functionalities for apps built with Ionic framework.
For a sample, just have a look at ionic-logging-viewer.
Usage
First, you need to import the LoggingServiceModule
in your AppModule
. The next step is typically the configuration (see below). And then, finally, you can use the LoggingService
in your code, e.g.:
import { Logger, LoggingService } from "ionic-logging-service";
export class MyComponent {
private logger: Logger;
constructor(
loggingService: LoggingService) {
this.logger = loggingService.getLogger("MyApp.MyComponent");
const methodName = "ctor";
this.logger.entry(methodName);
...
this.logger.exit(methodName);
}
public myMethod(index: number, message: string): number[] {
const methodName = "myMethod";
this.logger.entry(methodName, index, number);
try {
...
} catch (e) {
this.logger.error(methodName, "some error", e);
}
this.logger.exit(methodName);
return result;
}
}
Depending how the code is called, this could produce the following output in the browser's console:
I 18:49:43.794 MyApp.MyComponent ctor entry
I 18:49:43.797 MyApp.MyComponent ctor exit
I 18:49:43.801 MyApp.MyComponent myMethod entry 42 Hello
E 18:49:43.814 MyApp.MyComponent myMethod some error
I 18:49:43.801 MyApp.MyComponent myMethod exit [2, 5, 99]
Logger
A logger is the component responsible for logging. Typically, you have one logger per every class. The logger name describe the place where in your app the class is placed. The single parts are separated by dots ('.'). This is quite the same as with namespaces in dotnet or packages in Java.
This builds some kind of hierarchy. E.g., if you have a logger named A.B.C.D
, you get automatically also loggers for A.B.C
, A.B
and A
. Additionally, there is the so-called root logger, which is the parent of all other loggers.
The hierarchy is important, since the loggers inherit the log level from there parent - if there is no other level defined. That means, you can define just one log level for the complete app (by setting the root logger's level), and you can par example define, you do not want to see logs written for logger A.B.C
(this includes also A.B.C.D
).
Level
Every log message has a level. This is the severity of the message. Available levels are TRACE
, DEBUG
, INFO
, WARN
, ERROR
and FATAL
- these correspond to the logging methods trace
, debug
, info
, warn
, error
and fatal
of Logger
. Levels are ordered as follows: TRACE
< DEBUG
< INFO
< WARN
< ERROR
< FATAL
. This means the FATAL
is the most severe and TRACE
the least. Also included are levels called ALL
and OFF
intended to enable or disable all logging respectively.
Setting a level to a logger disables log messages of severity lower than that level. For instance, if a level of INFO
is set on a logger then only log messages of severity INFO
or greater will be logged, meaning DEBUG
and TRACE
messages will not be logged.
Appender
Appenders make the logs visible, e.g. by writing them to the browser's console. This is quite useful during development, either in console or using ionic serve --consolelogs
. But later, you will need other logs:
AjaxAppender
: sends the log messages to a backend serverMemoryAppender
: keeps the log messages in memoryLocalStorageAppender
: stores the log messages in local storage
If you want to see a complete example, have a look at ionic-feedback-sample.
Configuration
By default, the following configuration is used:
Logger:
- root:
Level.WARN
- root:
Appender:
BrowserConsoleAppender
MemoryAppender
To change it, just call configure()
. This method takes an object of type LoggingServiceConfiguration
.
The recommended way is to place the configuration in environment.ts
:
export const environment = {
logging: {
...
}
};
Call configure()
in your app.module.ts
:
export function configureLogging(loggingService: LoggingService): () => void {
return () => loggingService.configure(environment.logging);
}
@NgModule({
...
imports: [
...
LoggingServiceModule
],
providers: [
{
deps: [LoggingService],
multi: true,
provide: APP_INITIALIZER,
useFactory: configureLogging
}
]
})
export class AppModule { }
logLevels
logLevels
gets an array of log level definitions for different loggers, e.g.
{
"logLevels": [
{
"loggerName": "root",
"logLevel": "DEBUG"
},
{
"loggerName": "MyApp.MyNamespace.MyLogger",
"logLevel": "INFO"
}
]
};
That means, instead of the default log level WARN
, you want to log all messages with level DEBUG
and higher. Only for MyApp.MyNamespace.MyLogger
, you want to restrict the level to INFO
.
ajaxAppender
With ajaxAppender
, you add an additional appender of type AjaxAppender
, which sends the log messages to a backend server.
browserConsoleAppender
With browserConsoleAppender
, it is possible to configure the BrowserConsoleAppender
, which writes the log to the browser's console.
localStorageAppender
With localStorageAppender
, you add an additional appender of type LocalStorageAppender
, which stores log messages in the local storage.
memoryAppender
With memoryAppender
, it is possible to configure the MemoryAppender
, which keeps log messages in the memory.
API
see API documentation.