Source parsing
Decompose programs into jobs, steps, statements, tables, variables, expressions, procedures and source positions.
How it works
ELSii works from the evidence SAS leaves behind.
ELSii analyses SAS source programs and uses available execution logs where needed to recover runtime-resolved code, particularly macro-generated SAS. It then resolves the relationships into a structured lineage model that preserves the evidence behind each conclusion.
SourcePrograms, steps, statements, tables, variables, expressions and source positions.
RuntimeExecuted SAS recovered from logs when macro resolution hides the final code.
IdentityLogical names, physical library locations and distinct table and variable instances.
OutputStructured JSON, audit evidence and interactive lineage views.
The ELSii process in a nutshell
The ELSii architecture.
INPUT
SAS programs
data mart.customer;
set work.customer_base;
age = intck('year',dob,today());
run;
+
INPUT
SAS execution logs
MPRINT(BUILD): PROC SQL; CREATE TABLE WORK.X AS SELECT ...
→
ELSii
Parse, reconstruct and resolve
Source parsing → runtime reconstruction → semantic enrichment → physical identity and instance resolution → canonical links and calculation records.
The engineering model
Lineage as an evidence record, not merely a graph.
ELSii preserves the evidence behind a lineage conclusion: the program and step, source position, logical and physical table identity, individual table and variable instances, including successive inputs and outputs, expressions and resolution status. Repeated overwrites of the same SAS table can therefore be represented as distinct instances rather than flattened into one object.
A SAS dataset name by itself is not enough to describe lineage reliably. The same name may be created, overwritten and consumed several times within an estate. ELSii therefore keeps the execution context and reconstructs individual table and variable instances, so a downstream dependency can be linked to the appropriate upstream version rather than merely to a matching name.
The model also retains supporting evidence. A lineage relationship can be connected back to its program, step, statement, source position, physical library location and calculation context. This makes the lineage inspectable and auditable rather than just visually plausible.
Runtime reconstruction
Where needed, recover macro-generated SAS from execution logs and analyse the resolved code.
Semantic enrichment
Resolve table membership, input/output relationships, KEEP/DROP/RENAME behaviour, calculations and supporting metadata.
Physical identity
Connect logical SAS names to physical library locations so identically named tables can be distinguished.
Instance reconstruction
Represent individual table inputs, outputs and successive overwrites, connecting the correct upstream and downstream versions.
Structured outputs
Produce evidence-backed JSON and interactive HTML lineage views for analysis, integration and review.
| Source structure | Jobs, steps, statements, code elements, procedures, tables, variables, expressions and source coordinates. |
| Dataset semantics | Input/output relationships plus KEEP, DROP, RENAME and related dataset behaviour. |
| Physical identity | Logical SAS names connected to physical library locations so identically named assets can be distinguished. |
| Instance lineage | Individual table inputs, outputs and repeated overwrites, including the upstream/downstream versions they connect. |
| Calculation evidence | Derived-variable expressions and dependencies prepared for normalized calculation analysis. |
What gets resolved
Relationships at the level migration teams actually need.
The model is designed to answer practical questions about both provenance and impact: what created this table or column, which exact version was involved, what expression changed it, what are its ultimate sources, and what downstream assets depend on it?
Libraries and datasets
Identify where data is read, created, replaced and passed onward.
Columns and variables
Trace variables through renames, carry-forward logic, joins and transformations.
Calculations
Capture the expression used to create a derived column and its upstream dependencies.
Macro-generated code
Use execution logs to analyse code that only becomes visible after macro resolution.
Process context
Keep lineage connected to the SAS program and statement context that produced it.
Unresolved areas
Make gaps visible rather than presenting uncertain lineage as fact.
Why logs matter
Macros can hide the code you need to migrate.
A SAS program can contain a macro call rather than the final statements that execute. Where runtime context is needed, ELSii uses execution logs to recover the resolved SAS and analyse the code that actually ran.
Designed for evidence, not theatre
ELSii does not need to pretend every SAS estate is 100% automatically resolvable.
The practical goal is to automate as much lineage as possible, identify what remains uncertain and give teams a clear basis for targeted manual review. Complex SAS estates contain constructs where the available evidence may be incomplete or where a relationship cannot yet be resolved with sufficient confidence.
ELSii keeps those distinctions visible. A supported relationship, a fallback inference and an unresolved item should not all look the same simply because a graph can draw an arrow between two objects.
This matters for migration planning because the unresolved portion is itself useful information. It tells a team where investigation is still required and helps separate automated discovery from the manual work that remains.
Evidence-backed, not certainty by presentation.
The aim is a lineage model that can show both what ELSii has established and where further review is required.
What ELSii captures
A detailed evidence base for your SAS estate.
ELSii captures the lineage, execution context and supporting metadata needed to understand how SAS data and logic move through an estate.
Data & identity
Table names
Library references
Physical library locations
Variable names
Variable type, length, format, informat and label
Logical and physical table identity
Distinct table and variable instances
Canonical table and variable identities
Lineage & transformations
Table-level lineage
Column-level lineage
Direct upstream sources
Ultimate upstream sources
Downstream dependencies
Calculations and expressions
Passthrough and renamed variables
Intermediate tables and variables
Overwritten tables and variables
Calculation identity and equivalence evidence
SAS logic & runtime
Original SAS source
Macro-generated and runtime-resolved SAS
Arrays, including nested arrays
Loops, including nested loops
KEEP / DROP / RENAME behaviour
DATA step and PROC context
Execution and job context
Evidence & traceability
Program, step and statement context
Source-code positions
Supporting evidence back to SAS code
Calculation and expression context
Resolution and confidence status
Unresolved items requiring review
Next