Logging

Logging is a fundamental aspect of software development and system administration, providing a valuable means to record and monitor the activities and events within an application or system.

This tutorial aims to equip you with the knowledge and skills to enable logging in your applications or systems effectively.

We will explore the essential concepts of logging, such as log levels, log formats, and log destinations.

By the end of this tutorial, you will have a clear understanding of how to incorporate logging into your projects and locate log files for analysis and debugging purposes.

Prerequisites

Completed the Getting Started Tutorial, specifically:
- Initialized LicenseManager (or LicenseHandler) with your configuration using the appropriate settings.
- Created a LicenseID using either LicenseID::fromKey or LicenseID::fromUser function, depending on the activation method you prefer.
- Implemented basic license management, including license activations, deactivations, and both online and local license checks.

Enabling Logging and Verifying Its Status

Logging is enabled within the Configuration object, prior to the product and license being configured within the application.

Note: Logging is disabled by default.

Logging can be enabled using the following method:

void LicenseSpring::ExtendedOptions::enableLogging( bool enable )

import logging

# Configure logging
logging.basicConfig(
    filename='app.log',   # Name of the log file
    filemode='a',         # Append to the file ('w' for overwrite)
    format='%(asctime)s - %(levelname)s - %(message)s',  # Log format
    level=logging.INFO    # Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
)

Warning: Logging is for developer use only, ensure it is disabled in your release builds.

To see how to enable logging in an application environment, see below:

std::string appName = "NAME"; //input name of application
std::string appVersion = "VERSION"; //input version of application

ExtendedOptions options;
options.enableLogging( true ); 

auto configuration = Configuration::Create(
     EncryptStr( "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" ),
     EncryptStr( "XXXXXXXXX-XXXXX-XXXXXXXXXXXXX_XXXXXX_XXXXXX" ), 
     EncryptStr( "XXXXXX" ),
     appName, appVersion, options );

auto licenseManager = LicenseManager::create( pConfiguration );

var options = new LicenseSpring.ExtendedOptions();
options.EnableLogging = true;

var configuration = new LicenseSpring.Configuration(
            apiKey: "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX", 
            sharedKey: "XXXXXXXXX-XXXXX-XXXXXXXXXXXXX_XXXXXX_XXXXXX", 
            productCode: "XXXXXX", 
            appName: "NAME",
            appVersion: "VERSION",
            extendedOptions: options );
            
var licenseManager = LicenseManager.GetInstance();
licenseManager.Initialize( configuration );

LicenseSpringConfiguration configuration = LicenseSpringConfiguration.builder()
                .apiKey( "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" )
                .productCode( "XXXXXX" )
                .sharedKey( "XXXXXXXXX-XXXXX-XXXXXXXXXXXXX_XXXXXX_XXXXXX" )
                .appName( "NAME" )
                .appVersion( "VERSION" )
                .requestLogging( Logger.Level.FULL ) 
                .build();

LicenseManager licenseManager = LicenseManager.getInstance();
licenseManager.initialize( configuration );

from licensespring.licensefile.config import Configuration
from licensespring.licensefile.license_manager import LicenseID, LicenseManager
import logging

# Configure logging
logging.basicConfig(
    filename='path_where_you_want_to_store_logs/app.log',   # Name of the log file
    filemode='a',         # Append to the file ('w' for overwrite)
    format='%(asctime)s - %(levelname)s - %(message)s',  # Log format
    level=logging.INFO    # Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
)

conf = Configuration(
        product="your_product_short_code",
        api_key="api_key",
        shared_key="shared_key",
        file_key="your_file_key",
        file_iv="file_iv",
        grace_period_conf=12,
        is_guard_file_enabled=True)


lm = LicenseManager(conf)
license_id = LicenseID.from_key("9FFA-2XZC-SNDJ-49LK")
license = lm.activate_license(license_id)
license.check()

Developers can chack for whether logging is enabled in the current Configuration through using:

bool LicenseSpring::ExtendedOptions::isLoggingEnabled()

Location of the Log File

The location of log files is a critical aspect of logging configuration, determining where logged data is stored and accessed for monitoring, debugging, and analysis purposes.

Default Location in Different Environments

The location of the log file depends on the operating system in use.

On Windows, the default SDK data location is: {SystemDrive}:/Users/{UserName}/AppData/Local/LicenseSpring/{ProductCode}

On Linux, the default SDK data location is: HOME/.LicenseSpring/LicenseSpring/{ProductCode}

On macOS, the default SDK data location is: ~/Library/Application Support/LicenseSpring/{ProductCode}

These default paths indicate where the log file and other SDK-related data are stored based on the specific operating system.

Getting Current Data Location

Log files are stored in the same location as all other LicenseSpring data, including your local license file.

To discover the specific location of this data on your device, you can utilize the corresponding functionality provided within your application.

std::wstring path = licenseManager->licenseFilePath();

Changing Data Location

Changing the data location involves modifying the application's configuration or settings to redirect where data, including log files, is stored.

Developers and administrators may implement this change to consolidate data in a centralized location, move data to faster storage media, or ensure data privacy and compliance with regulations.

licenseManager->setDataLocation(L"new/path/to/LicenseSpring/data");

Warning: If there's a license in the new location, it will be set as current license, otherwise the current license will be removed from memory.

PreviousLocal License File NextVirtual Machine Detection

Was this helpful?

Good night

hashtagPrerequisites

hashtagEnabling Logging and Verifying Its Status

hashtagLocation of the Log File

hashtagDefault Location in Different Environments

hashtagGetting Current Data Location

hashtagChanging Data Location

Prerequisites

Enabling Logging and Verifying Its Status

Location of the Log File

Default Location in Different Environments

Getting Current Data Location

Changing Data Location