Rapports d’utilisation de licence

Les rapports d’utilisation de licence montrent en détail comment votre application utilise les fonctionnalités, les champs et les restrictions de la licence. En activant le suivi de l’utilisation des licences, vous pouvez surveiller l’adoption des fonctionnalités, vérifier la conformité et fonder sur des données vos décisions de stratégie de licence.

Vue d’ensemble

La bibliothèque Babel Licensing comprend un système de suivi qui surveille automatiquement les accès aux composants de licence :

Utilisation des fonctionnalités : suivez quelles fonctionnalités sont utilisées, à quelle fréquence et par quels membres
Accès aux champs : surveillez quels champs de licence sont lus, ainsi que leurs valeurs
Validation des restrictions : enregistrez les contrôles de restriction et les résultats de validation
Collecte automatique : les données d’utilisation sont capturées de façon transparente, sans modifier le code
Fusion intelligente : le serveur combine intelligemment les rapports pour une analyse complète

Exemple d’application console

Pour commencer par un exemple pratique, clonez le dépôt console-licensing-report-example, qui montre comment suivre l’utilisation des licences et envoyer des rapports d’utilisation de licence avec les fonctionnalités de Babel Reporting.

Ouvrir un client Git

Ouvrez votre client Git habituel ou la ligne de commande.

Cloner le dépôt

Clonez le dépôt GitHub en exécutant la commande suivante :


git clone https://github.com/babelfornet/console-licensing-report-example.git

Accéder au répertoire du projet

Une fois le dépôt cloné, accédez au répertoire du projet :


cd console-licensing-report-example

Explorer et exécuter l’exemple

Vous pouvez maintenant explorer et exécuter le code de l’exemple.

L’exemple console-licensing-report-example montre comment intégrer la bibliothèque cliente Babel Licensing à votre application pour suivre l’utilisation des licences et envoyer des rapports d’utilisation de licence au Babel Licensing Service. Voici le détail du code :

Initialisation de BabelReporting et de BabelLicensing : le code de l’exemple initialise à la fois un objet BabelReporting pour l’envoi des rapports et un objet BabelLicensing pour la validation des licences.


private BabelReporting CreateReportingClient()
{
    var reporting = new BabelReporting();
 
    reporting.Configuration.ClientId = ClientId;
    reporting.Configuration.ServiceUrl = ServiceUrl;
    reporting.Configuration.UseHttp(http => {
        http.Timeout = TimeSpan.FromSeconds(3);
        http.Handler = new HttpClientHandler() {
            ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => true
        };
    });
 
    reporting.BeforeSendReport += (s, e) => {
        e.Report.Properties.Add("cmdline", Environment.CommandLine);
        e.Report.Properties.Add("username", Environment.UserName);
    };
 
    return reporting;
}
 
private BabelLicensing CreateLicensingClient()
{
    var config = new BabelLicensingConfiguration()
    {
        ServiceUrl = ServiceUrl,
        SignatureProvider = RSASignature.FromKeys(PublicKey),
        ClientId = ClientId
    };
 
    config.UseHttp(http => {
        http.Timeout = TimeSpan.FromSeconds(10);
        http.Handler = new HttpClientHandler()
        {
            ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => true
        };
    });
 
    // Register custom license factory to handle MemoryRestriction
    config.LicenseFactory = new CustomLicenseFactory();
 
    return new BabelLicensing(config);
}

Clé utilisateur et clé publique : le code de l’exemple utilise une clé utilisateur (UserKey) pour autoriser le client et une clé publique (PublicKey) pour vérifier la signature de la licence. Veillez à les remplacer par des clés valides. Pour générer une clé utilisateur, reportez-vous aux sections Licence flottante ou Activation de licence.
Validation de licence avec suivi : l’exemple montre comment valider une licence flottante et accéder à ses fonctionnalités, à ses champs et à ses restrictions. Tous les accès sont suivis automatiquement lorsque LicenseUsageTracking est activé :


private async Task ValidateLicenseAsync()
{
    try
    {
        // Acquire floating license
        var requestResult = await _licensing.RequestFloatingLicenseAsync(UserKey, typeof(Program));
        Console.WriteLine($"Floating license {requestResult.License.Id} acquired.");
 
        try
        {
            // Validate the license (this will be tracked)
            var result = await _licensing.ValidateLicenseAsync(UserKey, typeof(Program));
            var license = result.License;
 
            Console.WriteLine($"License validated: {license.Id}");
 
            foreach (var feature in license.Features)
            {
                Console.WriteLine($" Feature: {feature.Name} - {feature.Description}");
            }
 
            foreach (var field in license.Fields)
            {
                Console.WriteLine($" Field: {field.Name} = {field.Value}");
            }
 
            foreach (var restriction in license.Restrictions)
            {
                Console.WriteLine($" Restriction: {restriction.Name}");
            }
 
            // Simulate multiple accesses to demonstrate tracking
            var reportingFeature = license.Features.FirstOrDefault(f => f.Name == "Reporting");
            var field2Field = license.Fields.FirstOrDefault(f => f.Name == "field2");
 
            for (int i = 0; i < 5; i++)
            {
                var _ = reportingFeature?.Data;
                var __ = field2Field?.Value;
            }
 
            Console.WriteLine($"\nLicense validation completed.");
        }
        finally
        {
            // Always release the floating license when done
            await _licensing.ReleaseFloatingLicenseAsync(UserKey);
            Console.WriteLine("Floating license released.");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error validating license: {ex.Message}");
    }
}

Envoi du rapport d’utilisation de licence : la méthode SendLicenseReportAsync envoie au Babel Licensing Service les données de suivi accumulées :


private async Task SendLicenseReportAsync()
{
    var result = await _reporting.SendLicenseReportAsync(UserKey);
    if (result.IsError)
    {
        Console.WriteLine($"Error sending LicenseReport: {result.Error}");
        return;
    }
    Console.WriteLine("LicenseReport sent.");
}

Fabrique de licences personnalisée : l’exemple comprend une classe MemoryRestriction personnalisée et CustomLicenseFactory, pour montrer comment gérer des types de restriction personnalisés dans vos licences :


class MemoryRestriction : Restriction, ILicenseSerializable
{
    public override string Name => "Memory";
    public long TotalMemory { get; set; }
 
    public override ValidationResult Validate(ILicenseContext context, Type type, object instance)
    {
        ISystemInformation sys = (ISystemInformation)context.GetService(typeof(ISystemInformation));
 
        long totalMem = ToMegabytes(sys.TotalPhysicalMemory);
        if (totalMem < TotalMemory)
            return ValidationResult.Invalid;
 
        return base.Validate(context, type, instance);
    }
 
    private static long ToMegabytes(long bytes)
    {
        return bytes / 1024 / 1024;
    }
 
    // ILicenseSerializable implementation...
}
 
class CustomLicenseFactory : ILicenseFactory
{
    public Restriction CreateRestriction(string type)
    {
        string[] tokens = type.Split(':');
        string restriction = tokens[0];
 
        switch (restriction)
        {
            case "Memory":
                var memory = new MemoryRestriction();
                if (tokens.Length > 1)
                    memory.TotalMemory = long.Parse(tokens[1]);
                return memory;
            default:
                return null!;
        }
    }
 
    // Other ILicenseFactory methods...
}

Exemple de rapport d’utilisation de licence

L’exemple console-licensing-report-example montre concrètement comment suivre l’utilisation des licences et envoyer des rapports au Babel Licensing Service. En intégrant le suivi des licences à vos applications, vous pouvez surveiller l’adoption des fonctionnalités, vérifier la conformité et fonder sur des données vos décisions de stratégie de licence.

Activer le suivi des licences

Pour commencer à suivre l’utilisation des licences, activez le suivi avant de valider votre licence :


using Babel.Licensing.Reports;
 
// Enable tracking (must be called before license validation)
LicenseUsageTracking.Enable();
 
// Validate your license as usual
var license = licenseManager.Validate(key, type);
 
// Use licensed features - access is automatically tracked
var reportingFeature = license.Features["Reporting"];
var data = reportingFeature.Data;
 
var versionField = license.Fields["Version"];
var version = versionField.Value;

Envoyer des rapports d’utilisation de licence

Une fois le suivi activé, vous pouvez envoyer des rapports à votre Babel Licensing Service :


using Babel.Licensing.Services;
 
// Initialize the reporting service
var reporting = new BabelReporting();
reporting.Configuration.ServiceUrl = "https://licensing.example.com";
reporting.Configuration.ClientId = "MyApplication";
 
// Send the license report
var result = await reporting.SendLicenseReportAsync(userKey);
 
if (result.Success)
{
    Console.WriteLine($"Report sent successfully: {result.ReportUid}");
}
else
{
    Console.WriteLine($"Failed to send report: {result.Error?.Message}");
}

Éléments suivis

Suivi des accès aux fonctionnalités

Pour chaque fonctionnalité de votre licence à laquelle l’application accède :


// This access is automatically tracked
var feature = license.Features["Reporting"];
var data = feature.Data;  // Tracked: get_Data on Reporting feature

Informations suivies :

Nom et identifiant de la fonctionnalité
Membre utilisé (par exemple get_Data, get_IsEnabled)
Nombre d’accès
Horodatage du premier accès
Horodatage du dernier accès
Durée totale d’accès (temps écoulé entre le premier et le dernier accès)

Suivi des accès aux champs

Pour chaque champ lu dans votre licence :


// This access is automatically tracked
var field = license.Fields["Version"];
var value = field.Value;  // Tracked: get_Value on Version field

Informations suivies :

Nom du champ
Valeur du champ (tronquée à 12 caractères par souci de confidentialité)
Membre utilisé (par exemple get_Value)
Nombres d’accès et horodatages

Suivi de la validation des restrictions

Pour chaque restriction contrôlée :


// This validation is automatically tracked
var validation = license.Restrictions.Validate();

Informations suivies :

Nom et type de la restriction
Résultat de la validation (Pass/Fail)
Membre utilisé
Nombres d’accès et horodatages

Contenu du rapport

Chaque rapport d’utilisation de licence comprend trois sections principales :

1. Métadonnées de la licence

Informations de base sur la licence suivie :


{
  "license_id": "L-ABC-123",
  "license_type": "Standard",
  "issue_date": "2025-01-15",
  "expire_date": "2026-01-15",
  "support_expire_date": "2025-07-15",
  "licensee_name": "John Smith",
  "licensee_company": "ACME Corporation",
  "product_name": "EquiTrack",
  "product_version": "2.0"
}

2. Données de suivi de l’utilisation

Statistiques d’accès détaillées de tous les composants suivis :


{
  "features": [
    {
      "id": "F-001",
      "name": "Reporting",
      "members": [
        {
          "member": "get_Data",
          "access_count": 15,
          "first_access": "2025-01-20T10:30:00Z",
          "last_access": "2025-01-20T14:45:00Z",
          "access_time": "04:15:00"
        }
      ]
    }
  ],
  "fields": [
    {
      "name": "Version",
      "value": "2.0.1",
      "members": [
        {
          "member": "get_Value",
          "access_count": 3,
          "first_access": "2025-01-20T10:00:00Z"
        }
      ]
    }
  ],
  "restrictions": [
    {
      "name": "MachineLock",
      "type": "Hardware",
      "members": [
        {
          "member": "Validate",
          "access_count": 1,
          "validation_result": "Pass",
          "first_access": "2025-01-20T10:00:00Z"
        }
      ]
    }
  ]
}

3. Informations d’environnement et informations système

Contexte de l’application et de la machine (configurable) :

Nom et version de l’application, assemblies chargés
Détails du système d’exploitation
Informations matérielles (processeur, mémoire, disque)
Cartes réseau
Variables d’environnement (filtrées)
Processus en cours d’exécution (facultatif)

Options de configuration

Choisissez les données incluses dans vos rapports d’utilisation de licence :


var reporting = new BabelReporting();
 
// Configure license report options
reporting.Configuration.LicenseReportOptions = new LicenseReportOptions
{
    // What to track
    CollectFeaturesAccess = true,
    CollectFieldsAccess = true,
    CollectRestrictionsAccess = true,
 
    // Filter specific members (optional)
    CollectMembers = new List<string> { "get_Data", "get_IsEnabled" },
 
    // Environment information
    Environment = new EnvironmentReportOptions
    {
        CollectApplicationInformation = true,
        CollectLoadedAssemblies = true,
        CollectEnvironmentVariables = false,
        CollectProcessInformation = false
    },
 
    // System information
    System = new SystemReportOptions
    {
        CollectSystemInformation = true,
        CollectOsInformation = true,
        CollectProcessorInformation = true,
        CollectMemoryInformation = true,
        CollectDiskInformation = false,
        CollectDisplayInformation = false,
        CollectNetworkInformation = false
    },
 
    // Output options
    Formatted = true,  // Pretty-print JSON
    EncryptionKey = "my-secret-key"  // Optional encryption
};

Gérer les données suivies

Vérifier l’état du suivi


if (LicenseUsageTracking.IsEnabled)
{
    Console.WriteLine("License tracking is active");
}

Accéder aux informations suivies


// Get all tracked licenses
foreach (var info in LicenseUsageTracking.TrackedLicenses)
{
    Console.WriteLine($"License: {info.LicenseId}");
    Console.WriteLine($"Product: {info.ProductName} v{info.ProductVersion}");
 
    // Feature access details
    foreach (var feature in info.TrackedFeatures)
    {
        Console.WriteLine($"  Feature {feature.Name}:");
        Console.WriteLine($"    Accesses: {feature.AccessCount}");
        Console.WriteLine($"    First: {feature.FirstAccessTime}");
        Console.WriteLine($"    Last: {feature.LastAccessTime}");
    }
 
    // Field access details
    foreach (var field in info.TrackedFields)
    {
        Console.WriteLine($"  Field {field.Name}: {field.AccessCount} accesses");
    }
 
    // Restriction validation details
    foreach (var restriction in info.TrackedRestrictions)
    {
        Console.WriteLine($"  Restriction {restriction.Name}: {restriction.AccessCount} checks");
    }
}

Obtenir le suivi d’une licence précise


var trackingInfo = LicenseUsageTracking.GetTrackingInfo("L-ABC-123");
if (trackingInfo != null)
{
    Console.WriteLine($"Tracking {trackingInfo.TrackedFeatures.Count()} features");
}

Effacer les données de suivi


// Clear all tracked data without disabling tracking
LicenseUsageTracking.Clear();

Désactiver le suivi


// Disable tracking and clear all data
LicenseUsageTracking.Disable();

Personnaliser les rapports

Ajoutez des propriétés personnalisées à vos rapports d’utilisation de licence au moyen de l’événement BeforeSendReport :


reporting.BeforeSendReport += (s, e) =>
{
    // Add custom metadata
    e.Report.Properties.Add("application_mode", "production");
    e.Report.Properties.Add("user_count", activeUsers);
    e.Report.Properties.Add("deployment_id", deploymentId);
 
    // Cancel sending if needed
    if (shouldSkipReport)
    {
        e.Cancel = true;
    }
};

Fusion des rapports

Le Babel Licensing Service fusionne automatiquement les rapports d’utilisation de licence provenant du même client et de la même machine. Cette fusion apporte :

Statistiques cumulées : les nombres d’accès sont additionnés
Chronologie préservée : le premier accès le plus ancien et le dernier accès le plus récent sont conservés
Analyse historique : les habitudes d’utilisation complètes au fil du temps
Stockage efficace : un seul rapport complet par licence, machine et client

Lorsqu’un nouveau rapport arrive, le serveur :

Identifie les rapports existants qui ont le même identifiant de licence, le même identifiant de machine et le même identifiant de client
Fusionne les données de suivi par nom de composant et par membre
Cumule les nombres d’accès
Met à jour les plages horaires d’accès
Actualise les métadonnées avec les valeurs les plus récentes

Gestion des erreurs

Gérez proprement les échecs d’envoi des rapports :


reporting.AfterSendReport += (s, e) =>
{
    if (e.Error != null)
    {
        // Log the error
        logger.LogError(e.Error, "Failed to send license report");
 
        // Store report locally for retry
        SaveReportForRetry(e.Report);
    }
    else
    {
        logger.LogInformation($"Report sent: {e.Result.ReportUid}");
    }
};
 
var result = await reporting.SendLicenseReportAsync(userKey);

Bonnes pratiques

1. Activer le suivi au plus tôt

Activez le suivi avant de valider votre licence pour capturer tous les accès dès le début :


// GOOD: Enable before validation
LicenseUsageTracking.Enable();
var license = licenseManager.Validate(key, type);
 
// BAD: Enable after validation (misses initial access)
var license = licenseManager.Validate(key, type);
LicenseUsageTracking.Enable();

2. Envoyer périodiquement

Envoyez les rapports à intervalles réguliers ou à l’arrêt de l’application :


// Option 1: Periodic reporting
var timer = new Timer(async _ =>
{
    if (LicenseUsageTracking.IsEnabled)
    {
        await reporting.SendLicenseReportAsync(userKey);
        LicenseUsageTracking.Clear();  // Reset for next period
    }
}, null, TimeSpan.FromHours(1), TimeSpan.FromHours(1));
 
// Option 2: On application shutdown
AppDomain.CurrentDomain.ProcessExit += async (s, e) =>
{
    await reporting.SendLicenseReportAsync(userKey);
};

3. Réduire la collecte de données

Ne collectez que les données dont vous avez besoin, afin de réduire la taille des rapports et l’utilisation du réseau :


reporting.Configuration.LicenseReportOptions = new LicenseReportOptions
{
    CollectFeaturesAccess = true,   // Essential
    CollectFieldsAccess = false,    // Skip if not needed
    CollectRestrictionsAccess = true,  // For compliance
 
    System = new SystemReportOptions
    {
        CollectSystemInformation = true,
        CollectDiskInformation = false,  // Skip to reduce size
        CollectDisplayInformation = false
    }
};

4. Gérer les situations hors ligne

Stockez les rapports en local lorsque le serveur est injoignable :


var result = await reporting.SendLicenseReportAsync(userKey);
 
if (!result.Success)
{
    // Serialize and store report
    var reportJson = JsonSerializer.Serialize(result.Report);
    await File.WriteAllTextAsync("pending-reports/report-" + Guid.NewGuid() + ".json", reportJson);
}

5. Protéger les données sensibles

Chiffrez les rapports qui contiennent des informations sensibles :


reporting.Configuration.EncryptionKey = Configuration["Reporting:EncryptionKey"];
reporting.Configuration.LicenseReportOptions.EncryptionKey = reporting.Configuration.EncryptionKey;

Exemple : suivi complet des licences

Voici un exemple complet de suivi des licences dans une application réelle :


using Babel.Licensing;
using Babel.Licensing.Reports;
using Babel.Licensing.Services;
 
public class LicenseManager
{
    private readonly BabelReporting _reporting;
    private readonly Timer _reportTimer;
 
    public LicenseManager(IConfiguration configuration)
    {
        // Initialize reporting service
        _reporting = new BabelReporting();
        _reporting.Configuration.ServiceUrl = configuration["Licensing:ServiceUrl"];
        _reporting.Configuration.ClientId = "EquiTrack v2.0";
        _reporting.Configuration.EncryptionKey = configuration["Licensing:EncryptionKey"];
 
        // Configure what to track
        _reporting.Configuration.LicenseReportOptions = new LicenseReportOptions
        {
            CollectFeaturesAccess = true,
            CollectFieldsAccess = true,
            CollectRestrictionsAccess = true,
            Environment = new EnvironmentReportOptions
            {
                CollectApplicationInformation = true,
                CollectLoadedAssemblies = true
            },
            System = new SystemReportOptions
            {
                CollectSystemInformation = true,
                CollectOsInformation = true,
                CollectProcessorInformation = true,
                CollectMemoryInformation = true
            },
            Formatted = false  // Compact JSON for network efficiency
        };
 
        // Add custom properties before sending
        _reporting.BeforeSendReport += (s, e) =>
        {
            e.Report.Properties.Add("environment", configuration["Environment"]);
            e.Report.Properties.Add("version", Assembly.GetExecutingAssembly().GetName().Version.ToString());
        };
 
        // Handle send results
        _reporting.AfterSendReport += (s, e) =>
        {
            if (e.Error != null)
            {
                Logger.Error($"Failed to send license report: {e.Error.Message}");
            }
            else
            {
                Logger.Info($"License report sent: {e.Result.ReportUid}");
            }
        };
 
        // Send reports every 24 hours
        _reportTimer = new Timer(
            async _ => await SendLicenseReportAsync(),
            null,
            TimeSpan.FromHours(24),
            TimeSpan.FromHours(24)
        );
    }
 
    public ILicense ValidateLicense(string userKey, LicenseKeyTypes keyType)
    {
        // Enable tracking before validation
        LicenseUsageTracking.Enable();
 
        // Validate license
        var licenseManager = new BabelLicensing();
        var license = licenseManager.Validate(userKey, keyType);
 
        return license;
    }
 
    public async Task SendLicenseReportAsync()
    {
        if (!LicenseUsageTracking.IsEnabled)
            return;
 
        try
        {
            var result = await _reporting.SendLicenseReportAsync(_userKey);
 
            if (result.Success)
            {
                // Clear tracking data after successful send
                LicenseUsageTracking.Clear();
            }
        }
        catch (Exception ex)
        {
            Logger.Error($"Exception sending license report: {ex.Message}");
        }
    }
 
    public void Shutdown()
    {
        // Send final report on shutdown
        SendLicenseReportAsync().Wait(TimeSpan.FromSeconds(10));
 
        // Cleanup
        _reportTimer?.Dispose();
        LicenseUsageTracking.Disable();
    }
}

Analyse côté serveur

Une fois les rapports parvenus à votre Babel Licensing Service, vous pouvez :

Surveiller l’adoption des fonctionnalités : voir quelles fonctionnalités sont les plus utilisées
Repérer les fonctionnalités inutilisées : trouver les fonctionnalités auxquelles l’application n’accède jamais
Suivre les habitudes d’utilisation : analyser les heures et les fréquences d’accès
Vérifier la conformité : vous assurer que les restrictions sont bien contrôlées
Planifier la stratégie de licence : fonder sur des données les décisions de regroupement des fonctionnalités

Les rapports sont stockés avec toutes leurs métadonnées. Vous pouvez les interroger au moyen de l’API du Babel Licensing Service ou les consulter dans l’interface de gestion.

Rapports d’exception : envoyer des rapports de plantage et d’erreur
Rapports personnalisés : créer vos propres types de rapports
Licence flottante : générer des clés utilisateur pour les rapports
Activation de licence : activer des licences pour le suivi

Rapports d’utilisation de licence

Vue d’ensemble

Exemple d’application console

Ouvrir un client Git

Cloner le dépôt

Accéder au répertoire du projet

Explorer et exécuter l’exemple

Activer le suivi des licences

Envoyer des rapports d’utilisation de licence

Éléments suivis

Suivi des accès aux fonctionnalités

Suivi des accès aux champs

Suivi de la validation des restrictions

Contenu du rapport

1. Métadonnées de la licence

2. Données de suivi de l’utilisation

3. Informations d’environnement et informations système

Options de configuration

Gérer les données suivies

Vérifier l’état du suivi

Accéder aux informations suivies

Obtenir le suivi d’une licence précise

Effacer les données de suivi

Désactiver le suivi

Personnaliser les rapports

Fusion des rapports

Gestion des erreurs

Bonnes pratiques

1. Activer le suivi au plus tôt

2. Envoyer périodiquement

3. Réduire la collecte de données

4. Gérer les situations hors ligne

5. Protéger les données sensibles

Exemple : suivi complet des licences

Analyse côté serveur

Rubriques connexes