Tackle Data Gravity Insights

Tackle Data Gravity Insights is a new way to gain insights into your monolithic application code so that you can better refactor it into domain driven microservices. It takes a wholistic approach to application modernization and refactoring by triangulating between code, and, data, and transactional boundaries.

Application modernization is a complex topic with refactoring being the most complicated undertaking. Current tools only look at the application source code or only at the runtime traces when refactoring. This, however, yields a myopic view that doesn't take into account data relationships and transactional scopes. This project hopes to join the three views of application, data, and transactions into a 3D view of the all of the application relationships so that you can easily discover application domains of interest and refactor them into microservices. Accordingly, DGI consists of three key components:

1. Call-/Control-/Data-dependency Analysis (code2graph): This is a source code analysis component that extracts various static code interaction features pertaining to object/dataflow dependencies and their respective lifecycle information. It presents this information in a graphical format with Classes as nodes and their dataflow, call-return, and heap-dependency interactions edges.

2. Schema: This component of DGI infers the schema of the underlying databases used in the application. It presents this information in a graphical format with database tables and columns as nodes and their relationships (e.g., foreign key, etc.) as edges.

3. Transactions to graph (tx2graph): This component of DGI leverages Tackle-DiVA to perform a data-centric application analysis. It imports a set of target application source files (*.java/xml) and provides following analysis result files. It presents this information in a graphical format with database tables and classes as nodes and their transactional relationships as edges.

Installation

Tackle Data Gravity Insights is written in Python and can be installed using the Python package manager pip.

pip install -U tackle-dgi

Usage

You will need an instance of Neo4j to store the graphs that dgi creates. You can start one up in a docker container and set an environment variable to let dgi know where to find it.

docker run -d --name neo4j \
    -p 7474:7474 \
    -p 7687:7687 \
    -e NEO4J_AUTH="neo4j/tackle" \
    -e NEO4J_apoc_export_file_enabled=true \
    -e NEO4J_apoc_import_file_enabled=true \
    -e NEO4J_apoc_import_file_use__neo4j__config=true \
    -e NEO4JLABS_PLUGINS=\["apoc"\] \    
  neo4j

export NEO4J_BOLT_URL="bolt://neo4j:tackle@localhost:7687"    

You can now use the dgi command to load information about your application into the graph database.

dgi --help

Usage: dgi [OPTIONS] COMMAND [ARGS]...

  Tackle Data Gravity Insights

Options:
  -n, --neo4j-bolt TEXT           Neo4j Bolt URL
  -a, --abstraction TEXT          The level of abstraction to use when
                                  building the graph. Valid options are:
                                  class, method, or full.  [default: class]
  -q, --quiet / -v, --verbose     Be more quiet/verbose  [default: verbose]
  -c, --clear / -dnc, --dont-clear
                                  Clear (or don't clear) graph before loading
                                  [default: clear]
  --help                          Show this message and exit.

Commands:
  c2g   This command loads Code dependencies into the graph
  s2g   This command parses SQL schema DDL into a graph
  tx2g  This command loads DiVA database transactions into a graph

Links

Link to complete Documentation of the project

Code of Conduct

Refer to Konveyor's Code of Conduct here.