DEV Community: Raja Anbazhagan

Finally, You can Collect Web Vital metrics from AMP pages using Google Analytics

Raja Anbazhagan — Thu, 08 Apr 2021 17:16:06 +0000

If you don't know already, You can monitor your site's Web Vitals using Web-vitals script. Hooking it with the Web-Vitals-Report app, you have easy monitoring for site performance.

However, You can't run these scripts in AMP pages as 3^rdParty Scripts are a no-no. So there was no easier way to properly collect web vital metrics until now.

Recently AMP project started providing vitals like CLS, LCP and FID as performance variables. When I tried to implement this in my blog I had a couple of problems.

1) Google analytics Event values should be an integer. CLS, LCP, FID values will most likely have decimal points. This means the entire event will be dropped in google analytics.
2) If I wanted to use fractions, then I should use Google Analytics G4. Which is still in alpha and no official support from AMP.

So the obvious option I had was to submit a PR that would translate these values into something Google Analytics can understand. Thankfully the team accepted it. So here is what you have to do.

If you want to capture CLS metrics, You need to include the google analytics snippet for AMP as shown below.

<amp-analytics type="googleanalytics">
    <script type="application/json">
        {
          "vars": {
            "account": "👉 Provide site tracking ID here (e.g. UA-XXXXX-Y) 👈"
          },
          "triggers": {
            "capture CLS": {
              "on": "visible",
              "request": "event",
              "vars": {
                "eventCategory": "Web Vitals",
                "eventAction": "CLS",
                "eventLabel": "${clientId}-${pageViewId}-CLS",
                "eventValue": "$CALC(${cumulativeLayoutShift},1000,multiply,true)"
              }
            }
          }
        }
</script>
</amp-analytics>

Also, don't forget to set the tracking ID.

You can read the detailed write-up at Collect Core Web Vitals from AMP pages using Google Analytics @ raja.anbazhagan.dev

Drools integration with Spring Boot

Raja Anbazhagan — Tue, 16 Feb 2021 04:06:50 +0000

Drools is a versatile business rule engine that can elevate your application by externalizing a lot of decision logic. As the most application servers are now using Spring boot, let's understand how to use Drools with Spring boot.

For a simple example, you can create a KieContainer as shown below.

@Bean
public KieContainer getKieContainer() {
    KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
    kieFileSystem.write( ResourceFactory.newClassPathResource("discount.drl"));
    KieBuilder kb = kieServices.newKieBuilder(kieFileSystem);
    kb.buildAll();
    KieModule kieModule = kb.getKieModule();
    return kieServices.newKieContainer(kieModule.getReleaseId());
}

Once you have a container, You can execute the rules within it by creating a session and firing all rules.

More on this explained at Drools integration with Spring Boot.

Thymeleaf form-handling is underrated.

Raja Anbazhagan — Fri, 15 Jan 2021 13:46:10 +0000

Single-page applications may have sleek forms and, AJAX calls to supply details to the server. But it cannot beat the simplicity of form-submissions. With templating libraries like thymeleaf and its support towards Spring-MVC makes form handling hassle-free.

A typical way to handle form parameters is through @RequestParam annotation. For example, the following snippet is to take three form parameters to a POST endpoint.

@RequestMapping(value = "/", method = RequestMethod.POST)
public String handleForm(@RequestParam("firstName") String firstName,
    @RequestParam("lastName") String lastName, @RequestParam("role")
    Role role) {
  logger.info("first Name : {}", firstName);
  logger.info("Last Name : {}", lastName);
  logger.info("Role: {}", role);
  return "users";
}

But this would be cumbersome when the form has too many parameters. For this reason, Spring MVC lets you wrap the parameters into a Form-Backed bean.

To do this, you need to define a class that would represent the FORM elements as POJO. Then use this class as a @ModelAttribute.

@RequestMapping(value = "/", method = RequestMethod.POST)
public String createUser(@ModelAttribute UserInfo userInfo) {
  logger.info("first Name : {}", firstName);
  logger.info("Last Name : {}", lastName);
  logger.info("Role: {}", role);
  return "users";
}

Here is a simple tutorial and demo on Thymeleaf Form Handling in Spring Boot. This post explains how to keep model along with forms.

The @Scheduled annotation may be deceiving you..!

Raja Anbazhagan — Thu, 07 Jan 2021 12:52:47 +0000

Is your @Scheduled method with fixedRate is not firing exactly at the time interval configured? Here I try to explain this behaviour and how you can fix it.

It all has to do with the default ThreadPoolTaskScheduler that is provided by Spring Boot’s auto-configuration. This Executor’s thread pool size is 1 by default. Every method that uses @Scheduled annotation will have to use this single thread.

Spring has deliberately done this so that there won’t be two runs of the same method happening in parallel. To achieve parallelism, we need to do three things.

1) Enable Async Support by annotating the Spring Boot main class with @EnableAsync.
2) Mark The @Scheduled method with @Async.
3) Increase the default number of threads available using spring.task.scheduling.pool.size property.

You can find detailed explanation about this behaviour at the post about how The @Scheduled annotation may be deceiving you..!

Distributed Caching with Hazelcast

Raja Anbazhagan — Thu, 07 Jan 2021 12:46:50 +0000

Hazelcast is an in-memory data grid that helps share highly volatile data between multiple application instances. This approach gives the advantages of avoiding network round trips.

Here is a post about hazelcast with spring boot and how to monitor them with Hazelcast Management centre.

Spring Boot Hazelcast Cache

Store spring sessions in Separate Database

Raja Anbazhagan — Wed, 06 Jan 2021 12:28:25 +0000

Storing session details in Redis or database is usually a good idea. However,
the default implementation of spring-session-jdbc uses the primary data source to store and
retrieve data from the session related tables. This can be a problem when there is a large amount of session related
operations to the database.

The solution here is to define a custom datasource bean and mark it with @SpringSessionDataSource as shown below.

@Bean
@SpringSessionDataSource
public DataSource sessionDataSource() {
    return sessionDataSource();
}

However, when you define multiple data sources, you end up breaking the default auto-configurations involving the primary data source.

To avoid all that, you need to mark one datasource as primary and somehow create and feed the second datasource to the session auto-configuration.

Follow this post about Store spring sessions in Separate Database to learn how and why you should do it this way.