Transaction Configuration Center - AFP Calibration - Transactional Functions - Missing Links

You are able to draw the complete end to end transaction in enlighten,

But in TCC, the transaction is not shown at all in the list of transactions, or, the transaction is shown as Empty Transaction in the list of transactions with a 0 FP value

and with an incomplete full call graph (when right clicking on transaction -> view full call graph):

1. Run analysis.
2. Computing TCC results.
3. In TCC, find out that the transaction is missing from the transaction list of that the transaction is coming in the list but with 0 FP.
4. Checking the transaction graph, you find it incomplete in TCC when you are able to draw the entire transaction graph in Enlighten.

1. Validate customer expectation
   1. Connect to enlighten.
   2. Draw the complete end to end transaction.
   3. Connect to TCC.
   4. Load current results.
   5. Check that the transaction is not coming in the list of transactions in TCC or that it  is coming but  as invalid (FP value to 0).
   6. Check the full call graph of the transaction to find whether it is incomplete (not going until the data function).
      
      

2. If the transaction is not coming at all in the list of transaction, check if the transaction is not merged with another one, for that refer to SQL Queries - CAST Knowledge Base - Queries on Transactions - How to get the Merged object of a Main object in a Transaction Merge

3. If the transaction is coming in the transaction list but with 0 FP

1. 1. Check whether missing link, is a link that is ignored in TCC graph computation
      1. Consider the example of the below Enlighten Graphical view in which you want to identify the missing transaction from the JSP efile to the Oracle table:
         
         
         
         
      2. If one of the links is created by a custom job ( like a KB update tool) that is creating a link from an object B to a class A, the transaction call graph will stop at A as per  TCC - View call graph and View full call graph:
         When computing the Full Call Graph and Call Graph between an entry point to a data function or an end point, all links are used to compute the graph: inherit, relyon, etc. except Belongs To links and what we call internal escalated links (which are links that come from anonymous classes for example). The only exception to this is when the entry point is a class, in which case Belongs To links are taken into account to continue on methods (i.e. only at the beginning of the transaction).
         To have a complete transaction graph, your custom job should create a link toward the methods in the class and not toward the class.
         
         
      3. Retrieve the list of ObjectID for each object participating in the transaction by pressing CTRL+ALT+SHIFT+D and Zoom button(Zoom down or Up) in Enlighten:
         
         
         In the example the ids are: 249852, 298224, 112331, 112339, 112326,112092,113606, 114367, 113952, 16761
         
         

      4. Run the following query on the local database:

         Links participating in TCC

         select L.CALLER_ID, L.CALLED_ID
         from FP_ADJUSTED_LINKS_VW L -- Note: FP_ADJUSTED_LINKS_VW only exists since 8.3; before use CTV_LINKS table
         left outer join
           ( select distinct fa.IdAcc
                 from FusAcc fa
                 join ObjInf oi
                   on oi.IdObj     = fa.IdFus
                  and oi.InfTyp    = 110 -- INFTYP_LINK_INFORMATION (=110) cf. ObjDesc.h
                  and oi.InfSubTyp = 20  -- INFSUBTYP_LINK_ESC_FROM_CONTAINER (=20) cf. ObjDesc.h
             ) f
           on L.LINK_ID = f.IdAcc
         where ( ( f.IdAcc is null ) or ( ( L.LINK_TYPE_LO & 536870912 ) != 536870912 ) ) 
         AND ( L.CALLED_ID not in ( select Form_ID from DSS_Transaction ) )
         AND L.CALLER_ID in ( 249852, 298224, 112331, 112339, 112326,112092,113606, 114367, 113952) -- Replace with list of retrieved objects ids excluding the last one since it does not call any object 
         AND L.CALLED_ID in (298224, 112331, 112339, 112326,112092,113606, 114367, 113952, 16761)-- Replace with list of retrieved objects ids excluding the first one since it does not call any object
         ORDER by order by L.CALLER_ID,L.CALLED_ID 

         The query will return all the objects pairs (links) participating in the TCC graph. All missing pairs from the query result, that have visible links in Enlighten screenshot, are links that do not participate in the TCC graph. For example if the result of the above query is:

         112092;113606
         112326;112092
         112331;112092
         112339;112326
         112339;112331
         113606;114367
         113952;16761
         114367;113952
         249852;298224

         The link from objects with id 298224(Spring Controller) and 112339(Public Java Class) is missing from the query result

      5. Once the missing links are identified you should identify which part of the SELECT query is responsible for the missing link. For each missing pair, run the following query:

         DSS_Transaction

         select Form_ID from DSS_Transaction 
         where Form_ID = 112339 --Replace with detected called id

         1. If the above query returns a result, then the called object in question is defined as an Entry point for a transaction and it cannot be used as an element of another Call Graph. For example, if an object A is defined as an Entry Point and it is also called by the object B, if object B is defined as Entry Point, there will be no transaction through object A since A would be used twice (once as Entry Point and once as a node of a Call Graph) which is not allowed.

            You can verify that in TCC by detecting the Java class object in the entry points:

            

            If you want to have the full flow, you should exclude the intermediate class object from the list of entries points as it is described in TCC - Handling multiple entry points in a call graph. Add this object in the excluded items list and recalculate the function points.In our example the object in question is the Java class object:

            

            After the exclusion, only the JSP efile will appear as a TCC entry point:

            
            
            

         2. If the above query returns no result, then the link is ignored because it is an internally escalated link with properties InfTyp = 110 and InfSubTyp = 20, as described in TCC - Which links are used to define a transaction?. Verify that the technology is JEE and that the link is created from an inner or anonymous class ( you shoiuld verify this in the source code of calle and called object).
            1. If you verified the above, then this is expected behaviour
               
            2. If have not verified the above, then the link type should not be an internally escalated one. In this case this is a problem of wrong links created by the analyzer and you should treat this as a wrong link issue.
               
               
   2. Check if the links are missing because of an excluded large Strongly Connected Component (SCC) group

      A large SCC group is described in Transaction Configuration Center - Information - Definition and impacts of the large Strongly Connected Component

      1. To check whether the transaction is invalid because of a large SCC group refer to - Transaction Configuration Center - Information - How to check whether the transaction is invalid because of a large SCC group

         If you find transactions in this list, it explains why transaction is incomplete in TCC. Refer to the following page that provide you the list of root causes that can lead to a large SCC. We propose also steps to break or remove the Large SCC: Transaction Configuration Center - AFP Calibration - Reduce the Large Strongly Connected Component

         Why large SCC groups are removed from transaction computation?

         This functional choice has been made, because such a large SCC group means that there are too many links that have been created. Having such a large SCC in a transaction, will end up with a transaction that get access to most of the Data functions of the application and will then strongly impact the Function Point value of the application

1. 1. If links are missing but not because of large SCC group, contact CAST Support with Relevant input 

Relevant input

• CAST Support Tool (CST) - alias Sherlock (triplet, source code, and TCC log file).
• Screenshot showing the complete end to end transaction in enlighten
• Screenshot showing the transaction as invalid in TCC (the transaction name with the incomplete full call graph)

Tickets # 6564,# 11892