Chargement et Traitement des Données SAS ESM vers CAS

Attention : Ce code nécessite des droits administrateur.

Le script initialise une connexion à une base de données PostgreSQL (`pgesm`), puis configure une session CAS. Il commence par nettoyer l'environnement CAS en supprimant toutes les tables de la CASLIB 'esm'. Un format utilisateur pour les jours de la semaine est créé et promu en CAS. Le script lit diverses tables PostgreSQL (`esm_job`, `esm_node`, `esm_servers_stats_agg_min`, `esm_process_stats_agg_hour`, `esm_session`), effectuant des conversions de fuseaux horaires, des extractions d'informations temporelles (jours, heures), des calculs de durées et de volumes de données (Ko, Mo, Go, To). Des jointures (`PROC SQL`) sont réalisées pour enrichir les données avec des informations de groupe ESM. Les données sont ensuite agrégées et transformées en plusieurs tables CAS (esm.esm_jobs, esm.server_statistics, esm.server_statistics_hour, esm.concurrent_sessions, esm.sessions, esm.sessionsAVG, esm.sessionsDateCat, esm.sessionsUSERMAX), souvent avec des options de compression et de promotion pour optimiser l'accès et le partage. Une catégorisation basée sur la fréquence des jobs est également appliquée.

Analyse des données

Type : EXTERNE

Les données brutes proviennent d'une base de données PostgreSQL externe, accessible via la libname `pgesm` configurée au début du script. Les tables sources incluent `pgesm.esm_job`, `pgesm.esm_node`, `pgesm.esm_servers_stats_agg_min`, `pgesm.esm_process_stats_agg_hour` et `pgesm.esm_session`. Les tables de destination sont des tables CAS dans la CASLIB `esm` et `casuser`.

1 Bloc de code

Initialisation

Explication :
Initialise une macro-variable `timezone` à 'UTC'. Définit une libname `pgesm` pour établir une connexion à une base de données PostgreSQL externe. Démarre une session CAS et assigne toutes les CASLIBs disponibles à l'utilisateur, ce qui est essentiel pour interagir avec le Cloud Analytic Services.

Copié !

1	%let timezone = 'UTC';
2
3	LIBNAME pgesm postgres server='dsn' port=15432 user=userid password=userid database=esm;
4	cas;
5	caslib _all_ assign;

2 Bloc de code

PROC DELETE

Explication :
Supprime toutes les tables existantes dans la CASLIB `esm`. Cette étape est cruciale pour garantir que les données sont rechargées proprement à chaque exécution du script, évitant ainsi la duplication ou l'obsolescence.

Copié !

1	PROC DELETE DATA=esm._all_;
2	RUN;

3 Bloc de code

PROC FORMAT / CAS Actions

Explication :
Définit un format utilisateur `dow` qui mappe les valeurs numériques de 1 à 7 aux noms des jours de la semaine. Ce format est ensuite sauvegardé dans la CASLIB 'casformats', promu globalement pour être accessible à toutes les sessions CAS, et enfin listé pour vérification.

Copié !

1	PROC FORMAT casfmtlib="casformats";
2	value dow
3	1 = 'Sunday'
4	2 = 'Monday'
5	3 = 'Tuesday'
6	4 = 'Wednesday'
7	5 = 'Thursday'
8	6 = 'Friday'
9	7 = 'Saturday';
10	RUN;
11
12	cas casauto savefmtlib fmtlibname=casformats TABLE=dow replace;
13	cas casauto promotefmtlib fmtlibname='casformats' replace;
14	cas casauto listfmtranges fmtname=dow;

4 Bloc de code

DATA STEP Data

Explication :
Ce DATA STEP lit les données brutes des jobs (`pgesm.esm_job`). Il convertit les horodatages `from_date` et `to_date` vers le fuseau horaire spécifié. La variable `flow` est analysée pour créer des niveaux hiérarchiques (`flow`, `subflow`, `subsubflow`, `subsubsubflow`). Des métriques de durée d'exécution (secondes, minutes, heures) sont calculées, ainsi que le jour de la semaine, le jour du mois et l'heure de début. Les volumes d'octets lus et écrits sont convertis en unités plus grandes (Ko, Mo, Go, To).

Copié !

1	DATA esm_jobs;
2	SET pgesm.esm_job;
3	from_date = tzoneu2s(from_date, &timezone.);
4	to_date = tzoneu2s(to_date, &timezone.);
5	save=flow;
6	x=count(flow,":");
7	IF x ge 1 THEN
8	DO;
9	flow=scan(save, 1, ':');
10	subflow=scan(save, 2, ':');
11	END;
12	IF x ge 2 THEN
13	DO;
14	subsubflow=scan(save, 3, ':');
15	END;
16	IF x ge 3 THEN
17	DO;
18	subsubsubflow=scan(save, 3, ':');
19	END;
20	drop save x;
21
22	runtime_seconds=intck('sec',from_date,to_date);
23	runtime_minutes=runtime_seconds/60.0;
24	runtime_hours=runtime_minutes/60.0;
25	FORMAT dayofweekn dow.;
26	dayofweekn=weekday(datepart(from_date));
27	dayofmonth=day(datepart(from_date));
28	FORMAT time time.;
29	time=timepart(from_date);
30	hour=hour(time);
31
32	kilobytes_read = total_bytes_read/1024;
33	megabytes_read = kilobytes_read/1024;
34	gigabytes_read = megabytes_read/1024;
35	terabytes_read = gigabytes_read/1024;
36
37	kilobytes_written = total_bytes_written/1024;
38	megabytes_written = kilobytes_written/1024;
39	gigabytes_written = gigabytes_written/1024;
40	terabytes_written = gigabytes_written/1024;
41	RUN;

5 Bloc de code

PROC SQL Data

Explication :
Cette requête SQL joint la table temporaire `esm_jobs` (créée précédemment) avec la table `pgesm.esm_node` sur la colonne `hostname` afin d'ajouter la variable `esm_group` aux données des jobs, enrichissant ainsi le contexte des informations sur les serveurs.

Copié !

1	PROC SQL;
2	create TABLE esm_jobs_nodes as
3	select a.*, b.esm_group
4	from esm_jobs as a
5	join pgesm.esm_node as b on a.hostname = b.hostname
6	;
7	QUIT;

6 Bloc de code

DATA STEP Data

Explication :
Charge les données de la table `esm_jobs_nodes` (située dans la bibliothèque WORK) dans une nouvelle table CAS permanente nommée `esm.esm_jobs`. Les options `compress=yes`, `copies=0` et `promote=yes` sont appliquées pour optimiser le stockage, éviter les copies redondantes et rendre la table disponible globalement dans CAS.

Copié !

1
2	DATA esm.esm_jobs(compress=yes copies=0 promote=yes);
3	SET esm_jobs_nodes;
4	RUN;
5

7 Bloc de code

PROC SQL Data

Explication :
Cette requête SQL crée une table temporaire `tempflows` en agrégeant les données de `esm_jobs` (la table CAS). Elle regroupe les données par `flow`, `subflow`, `subsubflow` et jour, puis calcule les dates/heures minimales et maximales (`from_date`, `to_date`) pour chaque groupe, permettant d'identifier la plage de temps couverte par chaque flux.

Copié !

1	PROC SQL;
2	create TABLE tempflows as
3	select flow, subflow, subsubflow, day, min(from_date) FORMAT=datetime. as from_date, max(to_date) FORMAT=datetime. as to_date
4	from (
5
6	select flow, subflow, subsubflow, datepart(from_date) FORMAT=date. as day, min(from_date) FORMAT=datetime20. as from_date, max(to_date) FORMAT=datetime20. as to_date
7	from esm_jobs
8	group BY flow, subflow, subsubflow, day
9
10	)
11	group BY flow, subflow, subsubflow, day
12	;
13
14	QUIT;

8 Bloc de code

DATA STEP Data

Explication :
Lit les statistiques agrégées minimales des serveurs (`pgesm.esm_servers_stats_agg_min`). Convertit `time_stamp` au fuseau horaire spécifié, puis extrait et formate le jour de la semaine, le jour du mois et l'heure à partir de cet horodatage.

Copié !

1	DATA server_statistics_a;
2	SET pgesm.esm_servers_stats_agg_min;
3	time_stamp = tzoneu2s(time_stamp, &timezone.);
4	FORMAT dayofweekn dow.;
5	dayofweekn=weekday(datepart(time_stamp));
6	dayofmonth=day(datepart(time_stamp));
7	FORMAT time time.;
8	time=timepart(time_stamp);
9	hour=hour(time);
10	RUN;

9 Bloc de code

PROC SQL Data

Explication :
Joint la table `server_statistics_a` avec la table `pgesm.esm_node` sur la colonne `hostname` pour ajouter la variable `esm_group` aux statistiques des serveurs, regroupant ainsi les données par groupes ESM.

Copié !

1	PROC SQL;
2	create TABLE server_statistics as
3	select a.*, b.esm_group
4	from server_statistics_a as a
5	join pgesm.esm_node as b on a.hostname = b.hostname
6	;
7	QUIT;

10 Bloc de code

DATA STEP Data

Explication :
Charge la table temporaire `server_statistics` (du WORK) dans une nouvelle table CAS permanente nommée `esm.server_statistics`. Les options `compress=yes`, `copies=0` et `promote=yes` sont utilisées pour optimiser le stockage et rendre la table accessible globalement dans CAS.

Copié !

1
2	DATA esm.server_statistics(compress=yes copies=0 promote=yes);
3	SET server_statistics;
4	RUN;
5

11 Bloc de code

DATA STEP Data

Explication :
Lit les statistiques agrégées par heure des serveurs (`pgesm.esm_servers_stats_agg_hour`). Convertit `time_stamp` au fuseau horaire spécifié et extrait des informations temporelles (jour de la semaine, jour du mois, heure), puis charge directement ces données dans la table CAS `esm.server_statistics_hour`.

Copié !

1	DATA esm.server_statistics_hour(compress=yes copies=0 promote=yes);
2	SET pgesm.esm_servers_stats_agg_hour;
3	time_stamp = tzoneu2s(time_stamp, &timezone.);
4	FORMAT dayofweekn dow.;
5	dayofweekn=weekday(datepart(time_stamp));
6	dayofmonth=day(datepart(time_stamp));
7	FORMAT time time.;
8	time=timepart(time_stamp);
9	hour=hour(time);
10	RUN;

12 Bloc de code

PROC SQL Data

Explication :
Crée une table temporaire `c1` en sélectionnant et joignant les statistiques de processus par heure (`pgesm.esm_process_stats_agg_hour`) avec les informations de nœud (`pgesm.esm_node`), filtrant sur des types de processus ESM spécifiques. Ensuite, crée la table `concurrent_sessions` qui calcule le nombre de sessions concurrentes pour chaque combinaison d'horodatage, type ESM, utilisateur ESM et groupe ESM.

Copié !

1	PROC SQL;
2
3	create TABLE c1 as
4	select time_stamp as ts, esm_type, esm_user, a.hostname, esm_group
5	from pgesm.esm_process_stats_agg_hour as a
6	join pgesm.esm_node as b on a.hostname = b.hostname
7
8	where esm_type in ('WS', 'CMP', 'SPRE', 'Foundation', 'CS', 'Batch','CASW', 'CASC','GRID','python', 'R','STP','PWS')
9	;
10
11	create TABLE concurrent_sessions as
12	select ts, esm_type, esm_user, esm_group,
13	case
14	when count(*) < 2 THEN 0
15	ELSE count(*)
16	END as concurrent_sessions
17	from c1
18	group BY ts, esm_type, esm_user, esm_group
19	order BY 2,3,1
20	;
21	QUIT;

13 Bloc de code

DATA STEP Data

Explication :
Charge la table `concurrent_sessions` (du WORK) dans une nouvelle table CAS permanente nommée `esm.concurrent_sessions`. L'horodatage `ts` est converti au fuseau horaire spécifié, et des informations temporelles comme le jour de la semaine, le jour du mois et l'heure sont extraites.

Copié !

1	DATA esm.concurrent_sessions(compress=yes copies=0 promote=yes);
2	SET concurrent_sessions;
3	ts = tzoneu2s(ts, &timezone.);
4	dayofweekn=weekday(datepart(ts));
5	dayofmonth=day(datepart(ts));
6	FORMAT time time.;
7	time=timepart(ts);
8	hour=hour(time);
9	RUN;

14 Bloc de code

PROC SQL Data

Explication :
Crée une table temporaire `tempsess` en joignant les données brutes des sessions (`pgesm.esm_session`) avec les informations de nœud (`pgesm.esm_node`) pour inclure la variable `esm_group` dans les données de session.

Copié !

1	PROC SQL;
2
3	create TABLE tempsess as
4	select a.*, b.esm_group
5	from pgesm.esm_session as a
6	join pgesm.esm_node as b on a.hostname = b.hostname
7	;
8
9	QUIT;

15 Bloc de code

PROC SQL Data

Explication :
Ces requêtes SQL créent d'abord `temp1` en agrégeant les statistiques de CPU par `session_id`. Ensuite, `temp2` calcule le pourcentage d'utilisation CPU système par rapport au CPU utilisateur. Enfin, la table `sessions` est créée en joignant `tempsess` avec `temp2` pour ajouter ce pourcentage CPU aux informations de session.

Copié !

1	PROC SQL ;
2
3	create TABLE temp1 as
4	select
5	session_id,
6	max(sys_cpu) as sys_cpu,
7	max(user_cpu) as user_cpu
8
9	from pgesm.esm_process_stats_agg_min as a
10	group BY session_id
11
12	;
13
14	create TABLE temp2 as
15	select *, divide(sys_cpu,user_cpu) as sys_cpu_pct
16	from temp1
17	;
18
19	create TABLE sessions as
20	select a.*,b.sys_cpu_pct
21	from tempsess as a
22	left join temp2 as b on a.id = b.session_id
23	;
24
25	QUIT;

16 Bloc de code

DATA STEP Data

Explication :
Charge la table `sessions` (du WORK) dans une nouvelle table CAS permanente nommée `esm.sessions`. Extrait des informations temporelles de `start_time` (jour de la semaine, jour du mois, heure), calcule les volumes de données lus/écrits en différentes unités et détermine la durée d'exécution des sessions en secondes, minutes et heures.

Copié !

1	DATA esm.sessions (compress=yes copies=0 promote=yes);
2	SET sessions;
3	FORMAT dayofweekn dow.;
4	dayofweekn=weekday(datepart(start_time));
5	dayofmonth=day(datepart(start_time));
6	FORMAT time time.;
7	time=timepart(start_time);
8	hour=hour(time);
9	kilobytes_read = total_bytes_read/1024;
10	megabytes_read = kilobytes_read/1024;
11	gigabytes_read = gigabytes_read/1024;
12	terabytes_read = gigabytes_read/1024;
13
14	kilobytes_written = total_bytes_written/1024;
15	megabytes_written = kilobytes_written/1024;
16	gigabytes_written = gigabytes_written/1024;
17	terabytes_written = gigabytes_written/1024;
18	runtime_seconds=intck('sec',start_time,end_time);
19	runtime_minutes=runtime_seconds/60.0;
20	runtime_hours=runtime_minutes/60.0;
21	RUN;

17 Bloc de code

PROC MEANS Data

Explication :
Calcule des statistiques descriptives (par défaut, la moyenne) pour les variables spécifiées de la table CAS `esm.sessions`. Les résultats sont regroupés par `job_name` et `esm_group`, puis sauvegardés dans la table CAS temporaire `casuser.sessionsAVG`.

Copié !

1	PROC MEANS DATA=esm.sessions;
2	BY job_name esm_group;
3	var avg_cpu avg_memory kilobytes_read kilobytes_written runtime_minutes sys_cpu_pct;
4	OUTPUT OUT=casuser.sessionsAVG;
5	RUN;

18 Bloc de code

DATA STEP Data

Explication :
Lit uniquement les observations où `_stat_` est 'MEAN' de la table `casuser.sessionsAVG`. Traite les valeurs manquantes pour `kilobytes_read` et `kilobytes_written` en les remplaçant par 0. La table résultante est chargée dans la table CAS permanente `esm.sessionsAVG`.

Copié !

1	DATA esm.sessionsAVG(promote=yes compress=yes copies=0);
2	SET casuser.sessionsAVG (where=(_stat_ = 'MEAN'));
3	IF kilobytes_read = . THEN kilobytes_read = 0;
4	IF kilobytes_written = . THEN kilobytes_written = 0;
5	RUN;

19 Bloc de code

PROC MEANS Data

Explication :
Calcule des statistiques pour la variable `start_time` de la table CAS `esm.sessions`. La sortie est stockée dans la table CAS temporaire `casuser.sessionsStartTime`, utilisée ultérieurement pour déterminer la plage temporelle des données.

Copié !

1	PROC MEANS DATA=esm.sessions;
2	var start_time;
3	OUTPUT OUT=casuser.sessionsStartTime;
4	RUN;

20 Bloc de code

DATA STEP Data

Explication :
Lit les observations `MIN` et `MAX` de `start_time` depuis `casuser.sessionsStartTime`. Calcule le nombre de jours entre ces deux dates (`days`) et stocke cette valeur dans la macro-variable `&days` pour une réutilisation dans les étapes suivantes.

Copié !

1	DATA work.sessionsStartTime ;
2	SET casuser.sessionsStartTime (where=(_stat_ = 'MIN' or _stat_ = 'MAX'));
3	retain startDay;
4	date = datepart(start_time);
5	IF _stat_ = 'MIN' THEN startDay = date;
6	IF _stat_ = 'MAX' THEN stopDay = date;
7	days=intck ('day',startDay,stopDay);
8	call symput('days',days);
9	RUN;

21 Bloc de code

DATA STEP Data

Explication :
Crée une table CAS `esm.sessionsDateCat` à partir de `esm.sessionsAVG`. Cette étape utilise la macro-variable `&days` pour catégoriser la fréquence des sessions (`_freq_`) en différentes périodes (Intraday, Daily, Monthly, Weekly, Infrequent, Intermittent), spécifiquement pour les jobs se terminant par 'sas'.

Copié !

1	DATA esm.sessionsDateCat(promote=yes compress=yes copies=0);
2	LENGTH dateCat $12 floorID floorM floorW 8.;
3	SET esm.sessionsAVG;
4	drop floorID floorM floorW;
5	floorID = floor(&days);
6	floorM = floor(&days/31);
7	floorW = floor(&days/7);
8	IF scan(job_name,-1) = 'sas' THEN
9	DO;
10	IF _freq_ > floor(&days+2) THEN dateCat = 'Intraday';
11	ELSE IF _freq_ >= (&days-2) and _freq_ <= (&days+2) THEN dateCat ='Daily';
12	ELSE IF _freq_ >= floor(&days/31) and _freq_ <= floor((&days/31) +2) THEN dateCat ='Monthly';
13	ELSE IF _freq_ >= floor((&days/7) - 2)and _freq_ <= floor((&days/7) +2) THEN dateCat ='Weekly';
14	ELSE IF _freq_ < floor(&days/7) THEN dateCat = 'Infrequent';
15	ELSE dateCat='Intermittent';
16	END;
17	RUN;

22 Bloc de code

PROC MEANS Data

Explication :
Calcule des statistiques descriptives pour les variables spécifiées de la table CAS `esm.sessions`. Les résultats sont regroupés par `owner` et `esm_group`, puis stockés dans la table CAS temporaire `casuser.sessionsUSERAVG`.

Copié !

1	PROC MEANS DATA=esm.sessions;
2	BY owner esm_group;
3	var peak_cpu max_work total_bytes_read total_bytes_written runtime_minutes sys_cpu_pct ;
4	OUTPUT OUT=casuser.sessionsUSERAVG;
5	RUN;

23 Bloc de code

DATA STEP Data

Explication :
Lit uniquement les observations où `_stat_` est 'MAX' de la table `casuser.sessionsUSERAVG`. Traite les valeurs manquantes pour `total_bytes_read` et `total_bytes_written` en les remplaçant par 0. La table résultante est chargée dans la table CAS permanente `esm.sessionsUSERMAX`.

Copié !

1	DATA esm.sessionsUSERMAX(promote=yes compress=yes copies=0);
2	SET casuser.sessionsUSERAVG (where=(_stat_ = 'MAX'));
3	IF total_bytes_read = . THEN total_bytes_read = 0;
4	IF total_bytes_written = . THEN total_bytes_written = 0;
5	RUN;

Ce matériel est fourni "tel quel" par We Are Cas. Il n'y a aucune garantie, expresse ou implicite, quant à la qualité marchande ou à l'adéquation à un usage particulier concernant le matériel ou le code contenu dans les présentes. We Are Cas n'est pas responsable des erreurs dans ce matériel tel qu'il existe maintenant ou existera, et We Are Cas ne fournit pas de support technique pour celui-ci.

Retour à la liste