SAP Community - Morten Wittrock

Re: Understanding term message payload and the modification of it?

2023-12-18T15:25:26+01:00

Hi Johannes

Message payload and message body are the same thing.

Static and dynamic payload is not a distinction I'm familiar with. When you use a Content Modifier step to update the message body, you can configure whether or not Simple expressions should be evaluated in your payload or not. I guess you might think of that as static and dynamic payloads, but only in the particular context of the Content Modifier updating the message body.

Regards,

Morten

Re: Understanding term message payload and the modification of it?

2023-12-18T20:51:46+01:00

Hi shogun777

Yes, you can set the payload with a Groovy script, if that makes more sense in your particular situation. Use the Message.setBody method in the script to update the payload. See the example here.

Regards,

Morten

Re: Difference between SAP Cloud Platform Integration(CPI) and SAP Cloud Integration(CI)

2023-12-25T14:08:00+01:00

Hi Yuya

Yes, SAP Cloud Platform Integration (often abbreviated to CPI) is the same product as SAP Cloud Integration; only the name has changed. In 2021, SAP Cloud Platform was rebranded as SAP Business Technology Platform and therefore the SAP Cloud Platform Integration name no longer made sense.

Regards,

Morten

Re: Difference between SAP Cloud Platform Integration(CPI) and SAP Cloud Integration(CI)

2023-12-26T16:11:14+01:00

Hi koide_yuya

Best of luck with the certification.

Regards,

Morten

Re: CPI ? SAP Integration Suite file transfer from folder to SFTP server

2023-12-26T16:14:06+01:00

Hi stefsnijders

The Edge Integration Cell file adapter is still on the roadmap. It's scheduled for Q2 2024 at the moment. You can find the roadmap entry here.

Regards,

Morten

Generative AI and SAP Cloud Integration

2023-12-27T16:14:31+01:00

2023 has been the year of AI and of generative AI in particular. AI is not a new topic, of course. In fact it’s quite old. But since OpenAI launched ChatGPT in November of 2022, the pace of innovation in AI has gone through the roof with no sign of slowing down any time soon.

So it probably didn’t come as a huge surprise, when Jürgen Müller announced in his SAP TechEd 2023 keynote, that SAP is embedding generative AI into SAP Integration Suite.

(I’m going to refer to generative AI as GenAI in the rest of this blog post.)

One of the areas where GenAI is making a huge impact is coding assistants. That is, an AI copilot that assists developers by generating code, documentation etc. We don’t yet know the details of how SAP intends to embed GenAI into SAP Integration Suite, but an AI copilot for creating integration flows seems a pretty safe bet.

GenAI excels at creating text, so generating scripts in SAP Cloud Integration is another area where an AI copilot would make a lot of sense. And script generation is something we can experiment with already now, without having to wait for SAP’s AI copilot to launch.

Creating Groovy scripts with GenAI is an area I’d been wanting to look into for a while, so when OpenAI launched their custom GPT feature, I decided to give it a go.

What are custom GPTs?

Custom GPTs were announced at OpenAI’s DevDay conference in San Francisco in November, 2023. You can check out the announcement here. Custom GPTs are a way to specialise ChatGPT in a particular field or topic. They are built on the GPT-4 foundation model, OpenAI’s most powerful model so far. The model is specialised via prompting and so-called knowledge files; there is no coding or complex (and costly) fine-tuning involved in the process. This made a custom GPT a perfect fit for my project.

Custom GPTs can be shared, but at the moment, they are only available to ChatGPT Plus members (a paid subscription) and OpenAI enterprise customers. OpenAI plans to launch a store for custom GPTs at a later date.

Training GroovyScriptinator

An AI assistant needs a proper name, of course, and I named mine GroovyScriptinator. My approach to training was iterative: Try a prompt, identify anything that needs tweaking in the response, update the instructions accordingly and repeat.

Out of the box, GPT-4 is already very capable of generating Groovy code. For that reason, I focused my training efforts on the following three more specific areas:

The SAP Cloud Integration environment

Best practices

Creating idiomatic Groovy code

Here are some examples of instructions from the first category:

All generated code must be compatible with Groovy version 2.4

Don’t use Java libraries that require a Java version newer than Java 8

The generated script function must either be called processData or the Script step must be configured with the non-default function name

Here are some examples of instructions from the second category:

Always pass the payload as a Reader object to XmlSlurper and JsonSlurper

Don’t pretty-print XML and JSON unless there is a reason to

Use the log level at runtime or an externalized parameter to control logging

Here are some examples of instructions from the third category:

Don’t add a semicolon at the end of a statement

Don’t use both def and a type when declaring a variable

Don’t import classes that are already imported automatically in Groovy

At the moment, my instructions for GroovyScriptinator come in at around 1800 words, but that number will likely keep growing. 1800 words is roughly the length of this blog post without the code listings.

Taking GroovyScriptinator for a spin

While working on my custom GPT, I’ve been using a number of prompts for testing its performance. I’ve chosen four examples for this blog post to demonstrate what’s possible. For each example I’ve linked to the conversation, so you can see the full response for yourself.

Example 1: JSON processing

The first example is based on this question from the SAP Community. I edited out the part about an existing script, because I wanted GroovyScriptinator to come up with a full solution to the problem. This is the script it generated in response:

import com.sap.gateway.ip.core.customdev.util.Message

import groovy.json.JsonSlurper

import groovy.json.JsonOutput



def Message processData(Message message) {

    // Parse the JSON payload

    def jsonPayload = new JsonSlurper().parseText(message.getBody(String))



    // Remove the 'shippingPackages' object

    jsonPayload.remove('shippingPackages')



    // Set the modified JSON back to the message body

    message.setBody(JsonOutput.toJson(jsonPayload))



    return message

}

This script works and generates the requested output. It’s nicely formatted and even has decent comments. It’s actually pretty similar to my own answer to the same question.

The two scripts differ in one respect, though: The payload should really be passed to JsonSlurper as a Reader object instead of a String object (that way a large payload is not read needlessly into memory). This best practice is actually part of my GroovyScriptinator instructions, but it seems to have temporarily forgotten that (more on that below).

I asked it to correct this and received the following script in response:

import com.sap.gateway.ip.core.customdev.util.Message

import groovy.json.JsonSlurper

import groovy.json.JsonOutput



def Message processData(Message message) {

    // Access the JSON payload as a Reader

    def payloadReader = message.getBody(Reader)



    // Parse the JSON payload

    def jsonPayload = new JsonSlurper().parse(payloadReader)



    // Remove the 'shippingPackages' object

    jsonPayload.remove('shippingPackages')



    // Set the modified JSON back to the message body

    message.setBody(JsonOutput.toJson(jsonPayload))



    return message

}

This script also generates the requested output and correctly accesses the payload via the more efficient Reader. You can view the full conversation here.

Example 2: More JSON

My second example is based on this SAP Community question (JSON is a popular Groovy scripting topic). I once again edited out the part about an existing script to see GroovyScriptinator’s own solution to the problem. This is the script it generated for me:

import com.sap.gateway.ip.core.customdev.util.Message

import groovy.json.JsonSlurper

import groovy.json.JsonOutput



def Message processData(Message message) {

    // Parse the JSON payload

    def jsonParser = new JsonSlurper()

    def jsonPayload = message.getBody(Reader)

    def parsedJson = jsonParser.parse(jsonPayload)



    // Add the new root node

    def modifiedJson = [data: parsedJson]



    // Convert the modified JSON back to String

    String jsonString = JsonOutput.toJson(modifiedJson)



    // Set the modified JSON as the new payload

    message.setBody(jsonString)



    return message

}

The script works correctly and this time around, GroovyScriptinator correctly used a Reader to access the payload. It even pointed out that the provided input JSON is, in fact, not valid and that the script only works, when the input is valid.

The only thing I’d point out is that it’s a little odd to declare all variables with def except jsonString, which is declared with its type (String). It's a tiny detail, though. You can view the full conversation here.

Example 3: Environment variables

My third example is a script that I needed for myself. This is the prompt I used:

“I need a script that creates a plain text payload containing the names of all environment variables and their values. I would like the output formatted as "NAME = VALUE", one name/value pair on each line.”

This is the script I received in response:

import com.sap.gateway.ip.core.customdev.util.Message



def Message processData(Message message) {

    // StringBuilder for constructing the output

    def output = new StringBuilder()



    // Iterate over all environment variables and append them to the output

    System.env.each { key, value ->

        output << key << " = " << value << '\n'

    }



    // Set the generated string as the message payload

    message.setBody(output.toString())



    return message

}

This script works and it’s a very decent solution to my problem. Short, sweet and to the point. It uses a StringBuilder to compose the payload efficiently and even uses the Groovy way of appending to the StringBuilder with the << operator. The only thing I’d point out is that the appended string with the equals sign really should be in single quotes, but that’s a very minor gripe. You can view the full conversation here.

Example 4: Fixed-length format to CSV

The last example is a requirement I made up specifically for testing GroovyScriptinator. I used the following prompt:

“I need a script that turns a fixed-length format text payload into a comma-separated text payload.

The payload contains a number of lines. The columns in the file has the following lengths: 3, 6, 3, 5, 2

Trailing spaces should be removed from the fourth column (but only from the fourth column).

Here is an example input line:

xyz123456abcdef 99

Here is the corresponding output line:

xyz,123456,abc,def,99

You can assume that each line has the same length, and this length is the sum of the column lengths.”

Here’s the script that GroovyScriptinator responded with:

import com.sap.gateway.ip.core.customdev.util.Message



def Message processData(Message message) {

    // Define column lengths

    def columnLengths = [3, 6, 3, 5, 2]



    // Get the payload as a string

    def payload = message.getBody(String)

    def lines = payload.split('\n')

    def newLines = []



    lines.each { line ->

        def start = 0

        def columns = columnLengths.collect { length ->

            def column = line.substring(start, start + length)

            start += length

            column

        }



        // Trim trailing spaces from the fourth column

        columns[3] = columns[3].trim()



        // Join columns with commas

        newLines << columns.join(',')

    }



    // Set the modified payload back into the message

    message.setBody(newLines.join('\n'))



    return message

}

This script solves the problem as stated and is really quite nice. I basically don’t have any notes. It kept the column lengths in an appropriate data structure, rather than hardcoding them into the script. It even got it right that the fourth column has index 3. You can view the full conversation here.

So what’s the verdict?

The above examples are not staged and have not been doctored in any way. They are representative of the standard of the code created by the custom GPT. It does make mistakes (see the below FAQ), but in general the quality of the responses is very high. Many of the generated scripts are so good that they can be added to your integration flow as is or with minimal modifications. I’d like you to pause for a moment and think about how powerful that is!

So my conclusion is rather obvious: An AI copilot is a perfect fit for Groovy scripting in SAP Cloud Integration and there is no question whatsoever about feasibility. I have no doubt that GenAI will be part of your daily work as an SAP Cloud Integration developer. And it will likely happen sooner rather than later.

FAQ

You probably have a lot of questions! I’ve tried to answer some of them in the following FAQ, but please feel free to ask questions in the comments as well. If I missed any obvious ones I’ll add them to the FAQ.

Does this mean I don’t have to learn Groovy?

No. You can do SAP Cloud Integration development without knowing Groovy, but if you want to add Groovy scripting to your toolbox (and I definitely think you should!), then you need to learn the language.

But whyyyy? Can’t I just use GenAI to write all the code?

You could, of course. But what happens after the script has been generated? First off, you won’t know if it actually works. And even if it seems to work, you won’t know why or under which circumstances. If you then throw caution to the wind, deploy the script in production and it breaks, it will be your responsibility to fix it, but you’ll have no idea how to fix it.

This is the reason why it’s generally a really, really bad idea to add code that you do not understand to your integration solution. It will come back to ~~bite you in the~~ haunt you later on.

Does GenAI make mistakes?

Yes. If you have used ChatGPT or similar GenAI chatbots before, you have very likely experienced this yourself as well.

I’m really impressed with the quality of the code generated by my custom GPT. That doesn’t mean it’s foolproof, though! It will still sometimes gladly and confidently present you with code that has syntax errors or code that is syntactically correct but just doesn’t work. It also sometimes forgets parts of its instructions.

So if GenAI makes mistakes, does that mean it sucks and I can safely ignore it?

Absolutely not. It really just emphasizes the copilot role of GenAI coding assistants. A human in the pilot’s seat is still needed and with GenAI that person has a powerful productivity tool available to them.

If you ignore GenAI right now, you do so at your peril. This is not another technology fad that can be waited out with a bit of patience. Love it or hate it, you need to understand what GenAI is, what it can and cannot do and how it can be applied in your context.

Will you be releasing GroovyScriptinator?

If there’s interest, I might at some point. I'd like to tinker with it some more first, though.

Re: Generative AI and SAP Cloud Integration

2023-12-29T13:29:18+01:00

Interesting idea, Eurico. Let me think about it.

Regards,

Morten

Re: Generative AI and SAP Cloud Integration

2023-12-30T14:13:16+01:00

That's a use case as well, sure. As with the code, you should definitely still have a human in the loop, to determine if what you are getting is actually comprehensive. But GenAI can absolutely create test cases too.

Regards,

Morten

Re: Success Factor Replication(Xslt Mappping /Standard Mapping)

2024-01-02T14:03:32+01:00

Hi Fathi

Something happened to your screenshots. Also, please include sample XML as text, not graphics. That way it can be easily copypasted. Use the CODE button to insert the XML to preserve formatting and special characters.

Regards,

Morten

Re: Success Factor Replication(Xslt Mappping /Standard Mapping)

2024-01-02T16:14:31+01:00

Hi Fathi

This is very similar to your other question about mapping a SuccessFactors API response. This XSLT stylesheet will remove all employment_information elements with an end_date child element:

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="3.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xs="http://www.w3.org/2001/XMLSchema">
	<xsl:output method="xml" />
	<xsl:mode on-no-match="shallow-copy" />
	<xsl:template match="employment_information[end_date]"/>
</xsl:stylesheet>

Regards,

Morten

Re: Is it possible to read Parquet file in CPI?

2024-01-03T11:12:53+01:00

Hi Yuting

There are Java libraries available for parsing Parquet files, which means you can read Parquet content in a Groovy script. When evaluating libraries, keep in mind that the Java version in SAP Cloud Integration is still Java 8, so you can only use libraries that are compatible with Java 8.

Regards,

Morten

Re: Success Factor Replication(Xslt Mappping /Standard Mapping)

2024-01-03T16:36:11+01:00

Hi fethi_men

The stylesheet works with the sample data you included. I tested it before posting, of couse. If some other part of your iflow fails, that really has nothing to do with this question.

Regards,

Morten

Re: Message Mapping to XSLT

2024-01-04T10:48:13+01:00

Hi Federico

Interesting project. I don't think there is any documentation of the inner workings of message mappings, so it's probably reverse engineering all the way down.

Regards,

Morten

My favourite SAP Cloud Integration feature: Trading Partner Management

2024-02-01T17:16:50.865000+01:00

Welcome, fellow integrators, to the seventh installment of this blog post series, where I talk to SAP Cloud Integration practitioners, developers, architects and enthusiasts about their favourite feature of our favourite platform. This time around, I get to interview a true SAP integration veteran who has been a part of this community since the very beginning: Bhavesh Kantilal.

Welcome to the series, Bhavesh! Could you introduce yourself briefly, please?

My name is Bhavesh Kantilal. I am an independent freelance consultant based in Stockholm, Sweden, and I have been working with SAP integration technologies since SAP XI 3.0 and with SAP Cloud Integration from when it was called HCI 🙂

Thank you very much! And now the central question of this blog post series: What’s your favourite SAP Cloud Integration feature?

There are many features of SAP Cloud Integration I admire, but my current favourite is Trading Partner Management coupled with B2B monitoring. This feature has captivated me so much that I have dedicated a whole blog post series (comprising 18 posts so far) to it on my personal blog.

Why that feature in particular?

In the evolving landscape of cloud integration, where SaaS applications are becoming more prevalent, classic EDI and B2B transactions continue to coexist and flourish within major customer enterprises.

Consider a customer landscape involving integration with thousands of suppliers. This is typical in sectors like manufacturing, retail, and automotive, where integration occurs with numerous suppliers across various EDI standards like EDIFACT and ANSIX12. These integrations might be point-to-point via protocols like AS2 or through other EDI gateways and VAN mailboxes. In these B2B transactions, each trading partner maintains its own unique set of parameters, identifiers, and transformations. Often, the mapping and transformation are consistent, but what varies is the trading partner connectivity and control records or identifiers.

Trading Partner Management (TPM) in SAP Cloud Integration offers a comprehensive solution from SAP, where most parameters varying across partners are configurable in TPM. Your main focus then shifts to building mappings via MAGs or classical message mappings, while TPM handles the complexities of EDI transformations, partner connectivity, and adapter configurations.

TPM extensively utilizes the Partner Directory in SAP Cloud Integration yet simplifies this with a user-friendly UI. Along with the standard iflows provided by SAP, TPM facilitates a plug-and-play B2B architecture that, despite initial complexity, becomes straightforward with experience.

Moreover, TPM enables out-of-the-box B2B monitoring. If you're familiar with SAP PO, the B2B monitoring in TPM resembles SAP PO monitoring, allowing you to view your B2B payloads and navigate from B2B monitoring to your SAP message logs. You get 90 days of payload logging with TPM (unlike the usual 30 days on MPLs).

How do you see the future of Trading Partner Management?

One area for growth in TPM is out-of-the-box monitoring and alerting for failed B2B transactions, which is currently missing but is on the road map. If I were to predict the future, I'd expect SAP to soon release this as a pre-delivered feature, integrated either with Cloud ALM or the Alert Notification Service in BTP.

There are currently limitations in EDI and IDoc bundling, but I am confident that these will be addressed in upcoming releases. Similarly, EDI Functional Acknowledgments are presently supported only for AS2 adapters, and while workarounds exist (like using the ProcessDirect adapter), this feature is likely to be further enhanced by SAP.

Another missing feature is archival of your B2B messages to external services like the Document Management Service in BTP. This is a road map item from SAP and this is something that multiple customers need, considering that B2B transactions are legal documents and having a technical log and archive of these messages is mandatory for compliance reasons.

As customers transition their B2B migrations from SAP PO to SAP Cloud Integration, I foresee a scenario where SAP PO message mappings will be utilized in SAP Cloud Integration and integrated via TPM. This is a feature that will increasingly be adopted, particularly by customers who have been using SAP PO as their B2B gateway.

I explore alternative solutions to these challenges in my TPM blog series here.

Thanks a lot for sharing your insights, Bhavesh! It was great to catch up.

Re: I've got problems with CPILint , I need HELP !!

2024-03-07T10:24:03.905000+01:00

Happy to help! I'm adding an FAQ to GitHub and this is one of the questions. Basically, after the unified Integration Suite UI, you can no longer copy the hostname from the browser on Cloud Foundry. Instead. you have to copy it from a service key. The approach is described here: https://help.sap.com/docs/cloud-integration/sap-cloud-integration/http-calls-and-uri-components

Re: Celebrating International Pi Day

2024-03-14T18:59:34.159000+01:00

CPILint version 1.0.5 is here

2024-08-29T01:40:40.485000+02:00

The very first version of CPILint was released on August 31st, 2019. With the 5th anniversary just around the corner, I am excited to announce that version 1.0.5 is complete and ready for you to install.

If you already run version 1.0.4, you will automatically be notified that there is a new version available. You can also go directly to GitHub to download it.

In this blog post, I will give you an overview of what’s in version 1.0.5. If you are new to CPILint, let me start by giving you the elevator pitch:

CPILint is an open-source tool that automates your SAP Cloud Integration governance. It ships with a range of built-in rules covering topics like developer guidelines, naming conventions and security. You choose the rules you want to put in place, and CPILint does the heavy lifting of checking your integration flows for compliance.

Now, let’s take a look at all the good stuff in the new release!

OAuth 2.0 support

CPILint communicates with your SAP Cloud Integration tenant via the official OData API. This requires authorization, of course, and so far we’ve done this by providing a username and password.

In version 1.0.5, however, you can authorize simply by creating a service key for CPILint in the SAP BTP Cockpit and downloading it to your local machine. You use the new -key command line option to point to that key. CPILint then uses your key to authorize its API calls using the OAuth 2.0 client credentials flow.

This has several benefits for you. First off, you no longer need to provide a username and password. Second, since the tenant hostname is already in the key, you no longer need to provide that either. Third, running CPILint with minimal permissions is now very easy to get right. Finally, the OAuth 2.0 client credentials flow is more secure than basic authentication.

With the new OAuth 2.0 support, checking your entire tenant for compliance is now as simple as:

cpilint -key my-key.json -rules my-rules.xml

Short and sweet!

Rules file import

Up until now, every single rule you wanted to check had to be stored in a single rules file. With CPILint version 1.0.5, we get a lot more flexibility. The new version introduces the ability to import a rules file into another rules file. You do this using the new <import> element.

If you have, for instance, a separate rules file for a specific project package but also want to reuse naming conventions that apply to the entire tenant, you can now simply import those naming conventions into the project’s rules file like this:

<cpilint>
    <imports>
        <import src="/path/to/naming-conventions.xml"/>
    </imports>
    <rules>
        <!-- Your project-specific rules would go here. -->
    </rules>
</cpilint>

This feature opens up entirely new ways to shape and mold your rules files and I’m excited to see how the community will put it to use! To learn more about rules file imports, visit this wiki page.

New rule: UserRoles

UserRoles is a new rule in CPILint 1.0.5 that lets you specify which user roles should and should not be used in sender channels that support user role authorization (meaning AS2, AS4, HTTPS, IDoc, SOAP, XI, and OData). If you, for instance, do not allow the use of the default user role (ESBMessaging.send), you would add this rule:

<disallowed-user-roles>
    <disallow>ESBMessaging.send</disallow>
</disallowed-user-roles>

You can also use the UserRoles rule to require, for instance, that only certain custom user roles be used.

Other news

1.0.5 adds 30 supported names to the NamingConventions rule. Check out this page in the CPILint wiki for the full list of supported names.

There’s a new command line option called -skipvercheck that skips the automatic check for a new version. If you run CPILint in a non-interactive way, like for instance in a CI/CD pipeline or other automation context, you might want to do this to save a little time and bandwidth.

The DuplicateResourcesNotAllowed rule now supports JSON resources.

There is now an FAQ page in the project wiki.

Last but definitely not least: The CPILint ASCII art is now 3D. Yes, I saved the best for last!

Over to you

That’s it for the CPILint 1.0.5 overview. Take the new release for a spin and please share your feedback with me in the comments below.

Five years of CPILint

2024-08-31T14:00:00.036000+02:00

On this day five years ago, I released the first version of CPILint on GitHub. I finished the latest version two days ago, so this feels like a good time to take a break, enjoy a piece of birthday cake, and look back at the project’s early days.

(The cake is a “Kagemand”, by the way, which translates literally to “Cake Man”. They’re served at birthday parties in Denmark, and they’re delicious 😋)

Version 1.0.0 came out on August 31st, 2019, but my earliest notes are from the autumn of 2018. They were jotted down between meetings during a visit to SAP in Walldorf. Seeing those notes today, I’m quite surprised how many of the early ideas eventually made their way into CPILint.

Reading the notes also reminded me that I originally used a different name: Flowmon. I think it was supposed to be a portmanteau of “iflow” and “monitor”, but it’s not a very good name, is it? I’m glad I changed it 😅

Even though I ended up writing CPILint in Java, I initially wanted to implement it in pure XSLT. I had a Schematron-like meta-programming approach in mind with a stylesheet compiling rules into another stylesheet, that would then transform an iflow’s internal XML format into compliance notifications.

I still have half a prototype, but the technique ultimately felt too limiting and I abandoned it. I still quite like the idea, though. It’s quirky and just a little chaotic 🙃 And it’s not a bad thing that it didn’t work out, by the way! On the contrary, one of the wonderful things about hobby projects is that they let you follow new ideas to interesting places and generally - in the words of Kurt Vonnegut - fart around.

The first time I showed CPILint in public was at SAP Inside Track Walldorf in January 2019. I managed to have a prototype working just in time for the event. Committing publicly to doing a live demo in front of a large group of people is quite motivating after all 🫠

SIT Walldorf was also the first time I got to show off the CPILint logo:

I was certain that someone would fairly quickly spot where the inspiration for the logo came from. However, five years later, no one has pointed out the connection. I’m a big fan of retro gaming, and the Atari 2600 console from 1977 is about as retro as it gets. This is the Asteroids game cartridge:

Look familiar? 😛 For the fifth anniversary I’ve made these logo stickers:

I’ll bring stickers with me to events in autumn, so if you’d like one, do come up and say hi!

Well, the “Kagemand” beckons, so let me wrap this up. Working on CPILint for the last five years has been so much fun, and I have no intention of stopping here! The list of features that I want to implement is still very long, and I’m excited to bring them to you in future releases.

Thank you for reading and thank you for supporting CPILint!

Re: Five years of CPILint

2024-09-03T00:32:28.940000+02:00

Interesting use case, @EuricoBorges. It would be a great topic for a blog post 🙂

Re: 🔴 Automate your SAP Cloud Integration governance with CPILint

2024-09-25T21:39:30.749000+02:00

Hi Mohamed

This is not necessarily a good fit for static analysis. You often want to measure, right? That's, by definition, not static. That said, the Design Guidelines have some checks that are performance-related, so you could take a look at those.

Regards,

Morten