Page 51 - Kaleidoscope Academic Conference Proceedings 2024
P. 51

Innovation and Digital Transformation for a Sustainable World




                                                              3.5   Upgrade cycle evaluation

                                                              From  the  perspective  of  the  upgrade  cycle  assessment,
                                                              assuming customers add n new inspection rules every day,
                                                              the  average  upgrade  iteration  cycle  in  the  production
                                                              environment  is  30  days.  Suppose  the  upgrade  iteration  is
                                                              represented by formula (14), where “a” is the amount of code
                                                              or configuration to be modified for inspection rules (one line
                                                              of code is equivalent to one line of configuration), “b” is the
                                                              amount of compilation work required for the change, and “c”
                                                              is the complexity of the deployment.

                                                                                      =   (  ) +   (  ) +   (  )   (14)
               Figure 7 – Resource pool data with significant
                       improvement in data quality
                                                              The  implementation  approach  of  the  engine  incurs  a
                                                              complexity of 1 for each new rule, so the complexity for n
           3.3   Data incremental efficiency
                                                              rules  is  n.  Since  it  is  implemented  through  configuration,
                                                              there is no need to modify the code or recompile, resulting in
           In testing environment, we repeatedly executed inspection
           tasks for different volumes of host data using 5 rules. We   a workload of 0 for this part. Without the need to modify the
                                                              code, and implementing through configuration, it is possible
           measured the execution time of the inspection code based on
           expression  engine  at  different  data  volumes,  as  shown  in   to  upgrade  to  the  production  environment  in  real-time,
                                                              provided that the inspection expressions are ready. Therefore,
           Figure  8(A).  It’s  not  difficult  to  observe  that  the  engine
           execution time is almost linearly related to the data volume   using the engine approach, the overall iteration complexity
                                                              is simplified to formula (15):
           and doesn’t exhibit exponential growth. The experimentally
           obtained processing times are also fully capable of meeting
           the requirements of the production environment.                                   =            (15)
                                                              The  approach  of  implementing  directly  through  logic,  for
                                                              each new rule, requires an average addition of 5 lines of code,
                                                              resulting  in  a  complexity  of  5n  for  n  rules.  As  code
                                                              modification  is  necessary,  b(n)  is  not  equal  to  0.  Since
                                                              modification  of  the  program  is  needed  to  implement  new
                                                              functionalities,  and  the  iteration  cycle  is  30  days,  the
                                                              complexity of c(n) is between 1 and 30. Therefore, using the
                                                              approach of direct logic implementation, the overall iteration
                                                              complexity is expressed in formula (16):
            Figure 8 – (A) Execution time of inspection code based
            on expression engine under different data volumes. (B)                   = 5   +   (  ) +   ,    ∈ [1,30]   (16)
             Comparison of expression engine code volume and
                           logical code volume                               4.  CONCLUSION

           3.4   Code efficiency comparison                   This  paper  proposes  a  method  based  on  the  native
                                                              functionality  of  an  expression  engine  and  business
           After multiple practical tests, such as testing various rules in   extensions  in  different  scenarios.  This  method  enables
           the  CMDB  test  environment,  including  20  rules  for  bare   dynamic inspection of business data, effectively addressing
           metal,  13  rules  for  host  machines,  and  7  rules  for  virtusl   challenges  such  as  diverse  data  sources,  complex  data
           servers, the experimental results indicate that the basic code   analysis, and data management. Using the CMDB business
           volume of the expression engine is approximately 180 lines.   scenario as a case study, we apply the expression engine-
           For each additional rule, the expression code increases by 1   based  inspection  method  to  the  production  environment,
           line  (we  maintain  the  expressions  in  Mysql  for  ease  of   ultimately implementing a dynamic inspection solution for
           repeated configuration). In contrast, using direct logic code   various models in CMDB. Through the analysis and tracking
           for inspection has a basic code volume of about 50 lines, and   of data reported by 49 product sources and optimization by
           for each additional rule, an average of 5 lines of code needs   the reporting party,  the reporting accuracy stabilizes at over
           to be added. As the number of inspection rules increases, the   90%, with an average improvement of approximately 12%.
           overall code volume trend is shown in Figure 8(B). When the   This  inspection  method  can  meet  customer  business
           number of rules is 100, the code volume of this method is   requirements  without  code  modification  and  frequent
           reduced to 50% of the logical code. As the number of rules   production  environment  cutover,  particularly  in  scenarios
           continues  to  increase,  the  code  volume  of  this  method   with evolving business needs. Compared to traditional logic-
           eventually approaches 20% of the logical code, and the code   based  inspection  methods,  the  expression  engine-based
           reduction amount ultimately approaches 80%.        inspection method significantly reduces iteration complexity.





                                                           – 7 –
   46   47   48   49   50   51   52   53   54   55   56