Doc Technique - SMF Cost & Activity Analyzer V2

SMF Cost & Activity Analyzer V2 – Analyseur coûts, activité et chargeback mainframe

Objectif du guide

Installer, tester et exploiter smf_cost_activity_analyzer_v2.py, un utilitaire autonome qui analyse des exports SMF normalisés en CSV, JSON ou JSONL pour produire une synthèse activité, coûts, capacité, chargeback, comparaison baseline et détection d’anomalies.

Télécharger l’utilitaire SMF Cost & Activity Analyzer V2

Le bouton principal pointe explicitement vers /static/toolbox/smf_cost_activity_analyzer_v2.py. Dépose ce script dans static/toolbox/ pour l’exposer depuis IDEO-Lab.

Download smf_cost_activity_analyzer_v2.py Django static tag

SMF est la matière première historique de l’observabilité mainframe : activité jobs, accounting, CPU, zIIP, elapsed time, EXCP, DB2 getpages, API z/OS Connect, service classes, departments, chargeback et signaux d’incident. Cette V2 ne lit pas les records SMF binaires bruts : elle travaille sur des exports déjà convertis et normalisés.

Normalize

Lecture CSV, JSON et JSONL avec alias de colonnes et modèle de record commun.

Analyze

Agrégations jobs, users, applications, departments, service classes et hourly buckets.

Chargeback

Estimation de coût configurable, baseline comparison et exports pour FinOps mainframe.

Ce que le moteur analyse

Domaine	Signaux analysés	Diagnostic produit
Accounting jobs	`record_type`, `job_name`, `user_id`, `account`, `department`	Top jobs, top users, top departments, chargeback par entité.
CPU / zIIP	`cpu_seconds`, `ziip_seconds`, offload ratio	Jobs CPU-heavy, zIIP offload faible, coût CPU estimé.
I/O / EXCP	`excp_count`, elapsed/cpu ratio, workload type	Candidats I/O-heavy, wait-bound workloads, batch window pressure.
DB2	`db2_getpages`, service class, elapsed time	Jobs DB2 coûteux, getpages élevés, risque de régression SQL.
API / z/OS Connect	`api_requests`, `api_avg_ms`, transaction count	Latence API, coût par application, croissance de trafic.
Baseline compare	`--compare-base`, croissance CPU/coût/latence	Détection de dérive avant/après livraison ou changement batch.

Positionnement : cette V2 est pensée pour FinOps mainframe, capacity planning, audit batch, refacturation interne, tableaux de bord de production et analyse avant/après changement applicatif ou infrastructure.

Important : les fichiers input attendus sont des exports SMF déjà convertis. Pour lire des records binaires SMF, il faut d’abord passer par un extracteur site, un outil vendor, un programme REXX/COBOL, ou un pipeline de conversion vers CSV/JSONL.

Téléchargement des fichiers

Cette page fournit des liens explicites vers l’utilitaire Python, les samples, le pack complet et les rapports de démonstration. Pour IDEO-Lab, les fichiers doivent être placés sous /static/toolbox/.

Utilitaire principal

Script autonome Python, sans dépendance externe, utilisable en mode démo, batch, export ou comparaison baseline.

Download smf_cost_activity_analyzer_v2.py Static tag

Sample activity

Fichier courant pour analyse complète : jobs, users, apps, departments, service classes.

Download activity CSV

Sample baseline

Baseline de comparaison pour détecter croissance CPU, coût et latence API.

Download baseline CSV

Pack ZIP

Script, samples, exports et rapports générés pour tests rapides.

Download ZIP

Arborescence static recommandée

static/
  toolbox/
    smf_cost_activity_analyzer_v2.py
    smf_cost_activity_analyzer_v2_pack.zip
    sample_smf_v2_activity.csv
    sample_smf_v2_baseline.csv
    smf_cost_activity_analyzer_v2_guide.html

Contrôle visuel : les boutons de téléchargement doivent être visibles en haut de la page, dans l’onglet Téléchargement, dans l’onglet Installation et dans la section Fichiers input.

Installation de SMF Cost & Activity Analyzer V2

Le script est autonome et ne nécessite aucune base de données. Il suffit d’avoir Python disponible et un export SMF normalisé en CSV, JSON ou JSONL.

1. Arborescence locale recommandée

smf_cost_lab/
  bin/
    smf_cost_activity_analyzer_v2.py
  input/
    sample_smf_v2_activity.csv
    sample_smf_v2_baseline.csv
  output/
    reports/
    csv/
    json/

Lien direct du script à installer

Ce bouton pointe explicitement vers /static/toolbox/smf_cost_activity_analyzer_v2.py.

Download smf_cost_activity_analyzer_v2.py Django static tag

2. Installation Linux / macOS

mkdir -p smf_cost_lab/bin smf_cost_lab/input smf_cost_lab/output/reports smf_cost_lab/output/csv smf_cost_lab/output/json
cp smf_cost_activity_analyzer_v2.py smf_cost_lab/bin/
cp sample_smf_v2_activity.csv smf_cost_lab/input/
cp sample_smf_v2_baseline.csv smf_cost_lab/input/
cd smf_cost_lab
python3 bin/smf_cost_activity_analyzer_v2.py --demo

3. Installation Windows PowerShell

New-Item -ItemType Directory -Force smf_cost_lab\bin, smf_cost_lab\input, smf_cost_lab\output\reports, smf_cost_lab\output\csv, smf_cost_lab\output\json
Copy-Item .\smf_cost_activity_analyzer_v2.py .\smf_cost_lab\bin\
Copy-Item .\sample_smf_v2_activity.csv .\smf_cost_lab\input\
Copy-Item .\sample_smf_v2_baseline.csv .\smf_cost_lab\input\
Set-Location .\smf_cost_lab
python .\bin\smf_cost_activity_analyzer_v2.py --demo

4. Test de validation

python bin/smf_cost_activity_analyzer_v2.py input/sample_smf_v2_activity.csv \
  --compare-base input/sample_smf_v2_baseline.csv \
  --html output/reports/sample_smf_report.html \
  --json output/json/sample_smf_analysis.json \
  --csv-jobs output/csv/sample_smf_jobs.csv \
  --csv-users output/csv/sample_smf_users.csv \
  --csv-apps output/csv/sample_smf_applications.csv \
  --csv-departments output/csv/sample_smf_departments.csv \
  --csv-service-classes output/csv/sample_smf_service_classes.csv \
  --csv-hourly output/csv/sample_smf_hourly.csv \
  --csv-findings output/csv/sample_smf_findings.csv \
  --csv-compare output/csv/sample_smf_compare.csv

Résultat attendu : le sample doit produire un rapport HTML, une estimation de coût, des top jobs/apps/users, des findings, une analyse horaire et une comparaison baseline/current.

Fichiers input attendus

SMF Cost & Activity Analyzer V2 accepte des exports CSV, JSON ou JSONL. Le format doit déjà contenir des champs normalisés ou des alias proches. Le script ne lit pas directement le binaire SMF produit par z/OS.

Utilitaire nécessaire pour analyser les inputs

Télécharger d’abord le script Python, puis lancer l’analyse sur le fichier SMF normalisé.

Download smf_cost_activity_analyzer_v2.py

1. Colonnes principales recommandées

Colonne	Rôle	Exemple
`timestamp`	Date/heure de l’activité.	`2026-05-22T02:00:00`
`record_type`	Type SMF ou famille logique.	`30`, `72`, `110`, `123`
`job_name`, `job_id`	Identification job / address space.	`PAYROLL1`, `JOB03197`
`user_id`, `account`, `department`	Chargeback et refacturation interne.	`FINOPS`, `PAYROLL`
`application`, `service_class`	Agrégation métier et WLM.	`PAYMENTS`, `BATCHHI`
`cpu_seconds`, `ziip_seconds`	Mesure CPU généraliste et zIIP.	`480.5`, `95.0`
`elapsed_seconds`, `queue_time_seconds`	Temps elapsed et attente.	`3600`, `180`
`excp_count`, `db2_getpages`	I/O et activité DB2.	`1250000`, `2500000`
`api_requests`, `api_avg_ms`	Mesure API / z/OS Connect.	`18000`, `750`
`max_rc`, `abend_code`	Signal incident ou batch failed.	`12`, `S0C7`

2. Exemple minimal de CSV

timestamp,record_type,system_id,lpar,job_name,job_id,user_id,department,application,service_class,workload_type,cpu_seconds,ziip_seconds,elapsed_seconds,excp_count,db2_getpages,api_requests,api_avg_ms,max_rc,abend_code,memory_mb,queue_time_seconds
2026-05-22T02:00:00,30,ZOS1,LPAR1,PAYROLL1,JOB03197,PAYUSR,FINANCE,PAYROLL,BATCHHI,BATCH,980.0,120.0,4200.0,1250000,2400000,0,0,12,S0C7,1024,90
2026-05-22T02:30:00,123,ZOS1,LPAR1,APIORD01,STC04412,APIUSR,DIGITAL,ORDER_API,ONLINEHI,API,120.0,380.0,900.0,45000,120000,18000,950,0,,768,25

3. Samples disponibles

Current activity

Export courant utilisé pour top jobs, top apps, chargeback et findings.

Download

Baseline

Export de référence pour calculer la croissance CPU, coût et latence.

Download

ZIP complet

Pack prêt à déposer dans un répertoire de test ou dans static/toolbox.

Download

Règle de sécurité : un export SMF peut contenir user IDs, jobnames, departments, accounting data, noms applicatifs et informations de charge. Utiliser --redact avant partage externe.

Utilisation quotidienne

1. Mode démo intégré

Le mode démo permet de tester immédiatement le moteur sans input externe.

python smf_cost_activity_analyzer_v2.py --demo

2. Générer les fichiers samples

python smf_cost_activity_analyzer_v2.py --write-sample-csv sample_smf_v2_activity.csv
python smf_cost_activity_analyzer_v2.py --write-baseline-csv sample_smf_v2_baseline.csv

3. Analyse simple d’un export SMF

python smf_cost_activity_analyzer_v2.py input/sample_smf_v2_activity.csv

4. Analyse complète avec baseline et exports

python smf_cost_activity_analyzer_v2.py input/sample_smf_v2_activity.csv \
  --compare-base input/sample_smf_v2_baseline.csv \
  --json output/json/sample_smf_analysis.json \
  --html output/reports/sample_smf_report.html \
  --csv-jobs output/csv/sample_smf_jobs.csv \
  --csv-users output/csv/sample_smf_users.csv \
  --csv-apps output/csv/sample_smf_applications.csv \
  --csv-departments output/csv/sample_smf_departments.csv \
  --csv-service-classes output/csv/sample_smf_service_classes.csv \
  --csv-hourly output/csv/sample_smf_hourly.csv \
  --csv-findings output/csv/sample_smf_findings.csv \
  --csv-compare output/csv/sample_smf_compare.csv

5. Mode anonymisé

python smf_cost_activity_analyzer_v2.py input/production_smf_export.csv \
  --redact \
  --html output/reports/production_smf_redacted.html \
  --json output/json/production_smf_redacted.json

6. Mode batch strict

python smf_cost_activity_analyzer_v2.py input/production_smf_export.csv \
  --profile chargeback \
  --html output/reports/production_smf_report.html \
  --csv-findings output/csv/production_smf_findings.csv \
  --fail-on-critical

Lecture recommandée : ouvrir d’abord le rapport HTML, puis exploiter les CSV pour Excel, Power BI, SQL ou historisation dans un portail d’exploitation.

Paramètres de ligne de commande

1. Paramètres d’entrée et de sortie

Paramètre	Description	Exemple
`input_file`	Export SMF normalisé CSV/JSON/JSONL.	`input/smf_export.csv`
`--demo`	Lance l’analyse avec records intégrés.	`--demo`
`--write-sample-csv`	Génère le sample courant.	`--write-sample-csv sample.csv`
`--write-baseline-csv`	Génère un sample baseline.	`--write-baseline-csv baseline.csv`
`--compare-base`	Compare current vs baseline.	`--compare-base baseline.csv`
`--profile`	Profil : production, batch, api, db2, capacity, chargeback, training.	`--profile chargeback`
`--redact`	Anonymise les valeurs identifiantes.	`--redact`
`--json`, `--html`	Exports principaux.	`--html report.html`
`--csv-jobs`, `--csv-users`, `--csv-apps`	Exports agrégés.	`--csv-jobs jobs.csv`
`--csv-departments`, `--csv-service-classes`	Exports chargeback et WLM.	`--csv-departments departments.csv`
`--csv-hourly`	Export par fenêtre horaire.	`--csv-hourly hourly.csv`
`--csv-findings`, `--csv-compare`	Anomalies et comparaison baseline.	`--csv-compare compare.csv`
`--fail-on-critical`, `--fail-on-error`	Codes retour stricts pour batch/supervision.	`--fail-on-error`

2. Paramètres de seuils

Paramètre	Rôle	Usage recommandé
`--job-cpu-warning`, `--job-cpu-critical`	Seuils CPU job.	Identifier les top jobs CPU-heavy.
`--elapsed-warning`, `--elapsed-critical`	Seuils elapsed.	Repérer les jobs longs ou batch windows en tension.
`--excp-warning`, `--excp-critical`	Seuils EXCP.	Détecter workloads I/O-heavy.
`--db2-getpages-warning`, `--db2-getpages-critical`	Seuils DB2.	Détecter activité DB2 excessive.
`--api-latency-warning`, `--api-latency-critical`	Seuils API.	Détecter z/OS Connect ou API lente.
`--ziip-offload-warning-pct`, `--ziip-offload-critical-pct`	Seuils zIIP.	Repérer un offload insuffisant.
`--queue-time-warning`	Seuil attente queue.	Repérer contention, scheduler, WLM ou ressources saturées.
`--compare-cpu-growth-pct`, `--compare-cost-growth-pct`	Seuils baseline.	Détecter dérive post-release.

3. Exemple avec seuils personnalisés

python smf_cost_activity_analyzer_v2.py input/production_smf_export.csv \
  --profile capacity \
  --job-cpu-warning 600 \
  --job-cpu-critical 1800 \
  --elapsed-warning 3600 \
  --elapsed-critical 14400 \
  --excp-warning 500000 \
  --excp-critical 2500000 \
  --html output/reports/production_capacity_report.html

Exemples d’utilisation

Scénario 1 – Audit chargeback mensuel

Objectif : produire les coûts estimés par application, user, department et service class.

python smf_cost_activity_analyzer_v2.py input/monthly_smf_export.csv \
  --profile chargeback \
  --html output/reports/monthly_chargeback.html \
  --csv-apps output/csv/monthly_apps.csv \
  --csv-departments output/csv/monthly_departments.csv \
  --csv-users output/csv/monthly_users.csv

Scénario 2 – Comparaison avant/après release

Objectif : détecter une dérive CPU, coût ou latence après livraison.

python smf_cost_activity_analyzer_v2.py input/after_release_smf.csv \
  --compare-base input/before_release_smf.csv \
  --profile production \
  --html output/reports/release_compare.html \
  --csv-compare output/csv/release_compare.csv \
  --csv-findings output/csv/release_findings.csv

Scénario 3 – Analyse z/OS Connect / API

Objectif : repérer latence API, coût par application et croissance de trafic.

python smf_cost_activity_analyzer_v2.py input/zos_connect_smf_123.csv \
  --profile api \
  --api-latency-warning 400 \
  --api-latency-critical 1200 \
  --html output/reports/api_activity.html \
  --csv-apps output/csv/api_apps.csv \
  --csv-findings output/csv/api_findings.csv

Scénario 4 – Analyse DB2 getpages

Objectif : isoler les jobs ou applications dont les lectures DB2 explosent.

python smf_cost_activity_analyzer_v2.py input/db2_smf_export.csv \
  --profile db2 \
  --db2-getpages-warning 750000 \
  --db2-getpages-critical 3000000 \
  --html output/reports/db2_getpages_report.html \
  --csv-jobs output/csv/db2_jobs.csv

Scénario 5 – Exécution nocturne automatisée

0 5 * * * /opt/smf-cost/bin/python /opt/smf-cost/smf_cost_activity_analyzer_v2.py \
  /data/smf/nightly_smf_export.csv \
  --compare-base /data/smf/baseline_smf_export.csv \
  --profile production \
  --html /var/www/reports/smf/nightly_smf_report.html \
  --csv-findings /var/log/smf/nightly_smf_findings.csv \
  --json /var/log/smf/nightly_smf_analysis.json \
  --fail-on-critical >> /var/log/smf/smf_cost_activity_analyzer.log 2>&1

Cost model et chargeback

La V2 embarque un modèle de coût configurable. Les valeurs ne sont pas des prix réels IBM ou vendor : ce sont des coefficients internes pour obtenir une mesure homogène et comparable entre jobs, applications, users et departments.

1. Coefficients de coût configurables

Paramètre	Signification	Valeur par défaut
`--cpu-second-rate`	Coût unitaire par seconde CPU généraliste.	`0.085`
`--ziip-second-rate`	Coût unitaire par seconde zIIP.	`0.018`
`--elapsed-second-rate`	Coût faible lié à l’occupation elapsed.	`0.0012`
`--excp-million-rate`	Coût par million d’EXCP.	`2.25`
`--db2-million-getpage-rate`	Coût par million de getpages DB2.	`0.95`
`--api-thousand-request-rate`	Coût par millier de requêtes API.	`0.12`
`--abend-penalty`	Pénalité forfaitaire si ABEND.	`35.0`
`--rc-error-penalty`	Pénalité si RC error.	`10.0`
`--rc-critical-penalty`	Pénalité si RC critique.	`25.0`

2. Exemple de modèle de coût personnalisé

python smf_cost_activity_analyzer_v2.py input/monthly_smf_export.csv \
  --profile chargeback \
  --cpu-second-rate 0.10 \
  --ziip-second-rate 0.02 \
  --excp-million-rate 3.00 \
  --db2-million-getpage-rate 1.20 \
  --api-thousand-request-rate 0.15 \
  --csv-departments output/csv/monthly_departments.csv \
  --csv-apps output/csv/monthly_applications.csv \
  --html output/reports/monthly_chargeback_report.html

3. Lecture des agrégats

Export	Lecture	Usage
`csv-jobs`	Coût et consommation par job.	Optimisation batch, recherche de jobs lourds.
`csv-users`	Coût et activité par user.	Audit, refacturation, analyse d’usage.
`csv-apps`	Coût et activité par application.	FinOps mainframe, arbitrage business.
`csv-departments`	Coût et activité par department.	Chargeback interne, showback, budget.
`csv-service-classes`	Coût et risque par WLM service class.	Capacity planning, WLM review.
`csv-hourly`	Consommation par heure.	Batch window, saturation nocturne, tendances.

Bonne pratique : le modèle de coût doit être calibré avec l’équipe capacity/finance. En première approche, il sert surtout à comparer les workloads entre eux et à détecter les dérives.

Exports et exploitation des résultats

Rapport HTML

Vue lisible : synthèse, coût, top applications, top findings, baseline comparison.

Analyse JSON

Format complet pour API, ingestion SQL, archivage ou comparaison automatique.

Jobs CSV

Une ligne par job agrégé, avec CPU, elapsed, EXCP, coût et risque.

Applications / Departments CSV

Vue chargeback / showback par application et département.

Hourly CSV

Vue temporelle pour batch window, capacity planning et pics d’activité.

Compare CSV

Diff current vs baseline pour détecter croissance CPU, coût ou latence.

Exemple de synthèse console

SMF Cost & Activity Analyzer V2
Records            : 8
Record types       : 30, 72, 110, 123
Jobs               : 6
Users              : 6
Applications       : 7
Departments        : 5
CPU seconds        : 3610.5
zIIP seconds       : 955.0
zIIP offload %     : 20.92
Estimated cost     : 721.43
Issues             : 52 (critical=11, error=19, warning=22)

Idée de table SQL pour historisation

CREATE TABLE smf_activity_run (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    source_name VARCHAR(255),
    profile_name VARCHAR(32),
    record_count INTEGER,
    job_count INTEGER,
    user_count INTEGER,
    application_count INTEGER,
    department_count INTEGER,
    cpu_seconds DECIMAL(18,3),
    ziip_seconds DECIMAL(18,3),
    elapsed_seconds DECIMAL(18,3),
    estimated_cost DECIMAL(18,3),
    critical_count INTEGER,
    error_count INTEGER,
    warning_count INTEGER,
    report_path VARCHAR(500),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Vision produit : la V2 devient une base solide pour un portail FinOps mainframe : historique SQL, dashboards, tendances, refacturation interne, capacity planning et analyse post-release.

Dépannage et bonnes pratiques

1. Le script ne lit aucun record

Cause possible	Correction
Le fichier est un dump SMF binaire brut.	Convertir d’abord en CSV, JSON ou JSONL avec un extracteur adapté.
Les noms de colonnes sont trop éloignés des alias connus.	Renommer les colonnes vers `cpu_seconds`, `job_name`, `application`, etc.
Les valeurs numériques contiennent des séparateurs non standard.	Nettoyer les valeurs avant ingestion, notamment virgules et formats locaux.
Le fichier mélange plusieurs layouts incompatibles.	Créer un export normalisé unique ou séparer par record type avant analyse.

2. Les scores ou coûts semblent trop agressifs

Les coefficients par défaut servent de démonstration. En environnement réel, il faut calibrer le modèle avec la politique interne de capacity planning, les coûts logiciels, les classes de service et les objectifs de reporting.

python smf_cost_activity_analyzer_v2.py input/production_smf_export.csv \
  --job-cpu-warning 1200 \
  --job-cpu-critical 3600 \
  --elapsed-warning 7200 \
  --elapsed-critical 21600 \
  --compare-cpu-growth-pct 50 \
  --compare-cost-growth-pct 50 \
  --html output/reports/production_smf_relaxed.html

3. Check-list avant partage d’un vrai export SMF

Utiliser --redact pour anonymiser job names, users, accounts, applications et departments.
Vérifier que les coûts générés sont des estimations internes, pas une facturation officielle.
Conserver une copie brute interne pour vérifier la fidélité de la conversion SMF vers CSV/JSONL.
Séparer online, batch, API et DB2 si les profils sont trop différents.
Comparer avec une baseline stable avant de conclure à une régression.

Point critique : un export SMF peut exposer des informations sensibles de production et d’organisation. Avant tout partage externe, générer une version anonymisée et valider les colonnes publiées.