From Java 8 to Java 11

Switching from Java 8 to Java 11 is more complicated than most updates. Here are some of my notes on the process.

Modules

Java 9 introduced one of the biggest changes in the history of Java modules. Much has been said on the subject, by other people. A key point is sometimes forgotten:

You do not need to modulate your code to update to Java 11.

In most cases, the code that runs in the class path will continue to run in Java 9 and later, where the modules will be completely ignored. This is terrible for library authors, but optimal for application developers.

So, my advice is to ignore the modules as much as you can when upgrading to Java 11. Transforming your application into Java modules can be a useful thing to consider in a few years when the free software dependencies really start adopting the modules. At the moment, trying to modularize is only painful, since few dependencies are modules.

(The main reason I found to modularize your application is to be able to use jlink to reduce the size of JDK.) But, in my opinion, you do not need to fully modulate to do this – just create a single jar – with dependencies with a simple no- requires no-exports module-info.)

Parties excluded from the JDK

Some parts of the JDK were removed. These were parts of Java EE and Corba that no longer fit the JDK or could be maintained elsewhere.

If you use Corba, then there is little that someone can do to help you. However, if you use the Java EE modules, the correction of the deleted code should be simple in most cases. You just have to add the appropriate Maven jars.

On the Java client side, things are more complicated with the removal of Java WebStart. Consider using Getdown or Update4Jinstead.

Unsafe and friends

Sun and Oracle have come to developers for years that do not use the sun.misc.Unsafe and other leading edge JDK APIs. For a long time, Java 9 was the launch where those classes disappeared. But that never really happened.

What you can get with Java 11, however, is a warning. This warning will only be printed once, on the first access to the restricted API. It is a useful reminder that your code, or a dependency, is doing something “impertinent” and will have to be corrected at some point.

What you will also discover is that Java 11 has several new APIs designed specifically to avoid the need to use Unsafee the friends. Make a priority to investigate these new APIs if you are using an “illegal” API. For example, Base64, MethodHandles.privateLookupIn, MethodHandles.Lookup.defineClass, StackWalker and Handles Variables.

Tools and Libraries

The modules and the new biannual launch cycle conspired to cause a real impact on the use of tools and libraries that developers use. Some projects were able to accompany. Some have fought. Some failed.

When updating to Java 11, an important task is to update all its dependencies to the latest version. If there is not a posting since Java 9 was released, then this dependency may need additional attention or testing. Make sure you have updated your IDE as well.

But it’s not just the dependencies of the applications that need to be updated, as well as Maven (and the Gradle too, but I do not know much about the Gradle). Most Maven plugins have changed major versions to v3.x, and upgrading Maven itself to v3.5.4 is also beneficial.

Unfortunately, the maven’s main equipment is very small, so there are still some errors / problems to solve. However, if your Maven construction is sensible and simple enough, it should usually be fine. But note that updating a plug-in from a v2.x to a v3.x can involve changes to the configuration in addition to those associated with the modules. For example, the Maven Javadoc plugin has changed the name of the argLine property.

Interested in learning Java? Join now:” java training in chennai “

An important point to be observed is the way in which Maven operates with the modules. When the Maven compiler or surefire plugin finds a jar file that is modular (that is, with a module-info.class), you can place that jar in the module path instead of the class path. In this way, even if you want to run the application completely on the classpath, Maven can compile and test the code partially on the classpath and partly on the module path. At the moment, there is nothing that can be done about it.

Sometimes, your compilation will need some larger changes. For example, you will have to change the Findbugs for SpotBugs. And change the Coverage to JaCoCo.

These compilation changes may take some time – they did it for me. But the information available for a simple investigation on the web is increasing all the time.

Interested in learning Java? Join now:” java training in bangalore “

Summary

I have updated several Joda / ThreeTen projects to support Java 9 or later now. It was very painful. But that’s because, as the author of a library, I have to produce a jar file with module information that is built and executed in Java 8, 9, 10 and 11. (In fact, some of my jar files run in Java 6 and 7 too!)

Having made these migrations, my conclusion is that the pain is mainly in maintaining compatibility with Java 8. Moving an application to Java 11 should be simpler, because there is no need to get stuck in Java 8.

November 27, 2018 0

Java 101

A complete introduction for beginners to the Java platform

So, do you want to program in Java? This is great and you have come to the right place. The Java 101 series provides a self-guided introduction to Java programming, starting with the basics and covering all the main concepts you need to know to become a productive Java developer. This series is technical, with many code examples to help you understand the concepts as we go. I guess you already have some experience in programming, but not in Java.

This inaugural article presents the Java platform and explains the difference between its three editions: Java SE, Java EE and Java ME. You will also learn about the role of the Java virtual machine (JVM) in the implementation of Java applications. I’ll help you set up a Java Development Kit (JDK) on your system so you can develop and run Java programs, and start with the architecture of a typical Java application. Finally, you will learn how to compile and run a simple Java application.

What is Java?

You can think of Java as a general-purpose object-oriented language that looks a lot like C and C ++, but which is easier to use and allows you to create more robust programs. Unfortunately, this definition does not offer much information about Java. A more detailed definition of Sun Microsystems is as relevant today as it was in 2000:

Java is a simple computer language, object oriented, intelligent in network, interpreted, robust, secure, with neutral architecture, portable, high performance, multithread and dynamic.

We will consider each of these definitions separately:

Java is a simple language. Java was initially modeled after C and C ++, minus some potentially confusing resources. Pointers, multiple implementation inheritance and operator overload are some C / C ++ resources that are not part of Java. A non-mandatory feature in C / C ++, but essential for Java, is a garbage collection feature that automatically retrieves objects and arrays.
Java is an object-oriented language. The object-oriented Java approach allows developers to work on Java adaptation to solve a problem instead of forcing us to manipulate the problem to meet language restrictions. This is different from a structured language like C. For example, while Java allows you to focus on objects in the savings account, C requires that you think separately about the state of the savings account (such balance) and behaviors ( as deposit and drawing).
Java is a language with network knowledge. The extensive Java network library makes it easy to manage TCP / IP network protocols, such as HTTP (Hypertext Transfer Protocol) and FTP (File Transfer Protocol) and simplifies the task of making network connections. In addition, Java programs can access objects through a TCP / IP network, through resource locations (URLs), with the same ease with which they are accessed from the local file system.
Java is an interpreted language. At run time, a Java program runs indirectly on the underlying platform (such as Windows or Linux) through a virtual machine (which is a software representation of a hypothetical platform) and the associated execution environment. The virtual machine translates the bytecodes of the Java program (instructions and associated data) for specific instructions of the platform by means of interpretation. Interpretation is the act of discovering what a bytecode instruction means and then choosing equivalent “canned” platform-specific instructions to execute. The virtual machine then executes these platform-specific instructions.

The interpretation facilitates the debugging of defective Java programs, because there is more information at compile time available at runtime. The interpretation also makes it possible to delay the connection stage between the parts of a Java program until the execution time, which accelerates the development.

Java is a robust language. Java programs must be trusted because they are used in personal and mission-critical applications, from Blu-ray players to air navigation systems or air control. The language resources that help make Java robust include declarations, duplicate type checking at compile time and runtime (to avoid version incompatibility issues), true arrays with automatic boundary checking and pointer omission. (We will discuss all of these resources in detail later in this series.)

Another aspect of Java’s robustness is that loops must be controlled by Boolean expressions instead of integer expressions, where 0 is false and a non-zero value is true. For example, Java does not allow a loop in style C, such as while (x) x ++; because the loop cannot end where it is expected. Instead, you must explicitly provide a Boolean expression, such as while (x! = 10) x ++; (which means that the loop will run until x equals 10).

Java is a safe language. Java programs are used in network / distributed environments. Because Java programs can migrate and run across multiple platforms on a network, it is important to protect these platforms against malicious code that can spread viruses, steal credit card information, or execute other malicious acts. The characteristics of the Java language that support robustness (such as the omission of pointers) work with security features, such as the Java sandbox security model and public-key cryptography. Together, these resources prevent viruses and other dangerous codes from wreaking havoc on an unmanned platform.

In theory, Java is safe. In practice, several security vulnerabilities have been detected and explored. As a result, Sun Microsystems and Oracle now continue to release security updates.

Interested in learning Java? Join now:” java training in chennai “

Java is a neutral language in architecture. Networks connect platforms with different architectures based on various microprocessors and operating systems. You can not expect Java to generate platform specific instructions and have those instructions “understood” by all types of platforms that are part of a network. Instead, Java generates platform-independent byte code instructions that are easy to interpret for each platform (through its JVM implementation).
Java is a portable language. The neutrality of architecture contributes to portability. However, there is more to Java portability than platform-independent byte code instructions. Consider that the sizes of integer types should not vary. For example, the 32-bit integer type should always be signed and occupy 32 bits, regardless of where the 32-bit integer is processed (for example, a platform with 16-bit registers, a platform with 32-bit registers or a table platform with 64-bit registers). Java libraries also contribute to portability. When necessary, they provide types that connect Java code to platform-specific resources in the most portable manner possible.

Interested in learning Java? Join now:” java training in bangalore “

Java is a high performance language. The interpretation produces a level of performance that is generally more than adequate. For high-performance application scenarios, Java uses just-in-time compilation, which analyzes interpreted bytecode instruction sequences and compiles frequently interpreted instruction sequences for platform-specific instructions. Subsequent attempts to interpret these sequences of bytecode instructions result in the execution of equivalent platform-specific instructions, resulting in increased performance.
Java is a multiprocess language. To improve the performance of programs that must perform several tasks at the same time, Java supports the concept of chained execution. For example, a program that manages a graphical user interface (GUI) while waiting for the input of a network connection uses another thread to execute the wait instead of using the standard GUI thread for the two tasks. This keeps the GUI responsive. The Java synchronization primitives allow the threads to securely communicate data with each other without corrupting the data. (See programming chained in Java, discussed elsewhere in the Java 101 series).
Java is a dynamic language. Because interconnections between program code and libraries occur dynamically at runtime, it is not necessary to explicitly link them. As a result, when a program or one of its libraries evolves (for example, for error correction or performance improvement), a developer only has to distribute the updated program or library. Although dynamic behavior produces less code to distribute when a version change occurs, this distribution policy can also lead to version conflicts. For example, a developer removes a class type from a library or renames it. When a company distributes the updated library, existing programs that depend on the type of class will fail. To greatly reduce this problem, Java supports a type of interface, which is like a contract between two parties.

November 26, 2018 0

Introduction to the Java Development Kit

Introduction

The Java Development Kit (JDK) is one of the three main technology packages used in Java programming, together with the JVM (Java Virtual Machine) and the JRE (Java Runtime Environment). It is important to differentiate these three technologies, as well as to understand how they are connected:

The JVM is the component of the Java platform that runs programs.
The JRE is the part of the Java disk that creates the JVM.
The JDK allows developers to create Java programs that can be executed and executed by JVM and JRE.

Beginning Java developers often confuse the Java Development Kit and the Java Runtime Environment. The distinction is that the JDK is a toolkit for Java-based software development, while the JRE is a suite of tools for executing Java code.

The JRE can be used as a separate component to run Java programs, but it is also part of the JDK. The JDK requires a JRE because running Java programs is part of their development.

Technical definition: The JDK is an implementation of the Java platform specification, including the compiler and the class libraries.
Definition of every day: JDK is a software package that downloads to create Java-based applications.

Start with the JDK

Obtaining Java configuration in your development environment is as easy as downloading a JDK and adding it to your classpath. When you download your JDK, you will need to select the Java version you want to use. Java 8 is the most commonly used version, but, so far, Java 10 is the most recent version. Java maintains compatibility with previous versions, so we will download the latest version.

Interested in learning Java? Join now:” java training in chennai “

JDK packages

In addition to choosing your version of Java, you will also have to select a Java package. The packages are Java development kits that are directed to different types of development. The available packages are Java Enterprise Edition (Java EE), Java Standard Edition (Java SE) and Java Mobile Edition (Java ME).

Beginning developers are sometimes not sure which package is right for their project. In general, each JDK version contains Java SE. If you download the Java EE or Java ME, you will get the standard edition with it. For example, the Jave EE is the standard platform with additional tools useful for the development of enterprise applications, such as Enterprise JavaBeans or support for Relational Object Mapping.

Interested in learning Java? Join now:” java training in bangalore “

It is also not difficult to change to a different JDK in the future if you find that you need it. Do not worry much about choosing the correct version of Java and the JDK package when you have just started.

November 24, 2018 0

Microservice Logging: Challenges and Advantages

One of the main developments in software design and delivery in recent years has been a movement of monolithic applications for microservices. One of the critical points that I have seen in several microservice applications is the registry. There are some unique challenges with the microsion log that need to be resolved. In this article, we will see how we can do the registration in a microservice as painless as in a monolith.

What is a microservice?

There are many definitions of microservices out there, but that’s the one I like.

Microservices: A high-level software design that favors small and weakly connected services that maintain data autonomy and are independently implantable.

Breaking this up using microinsurance is a high level decision. It is not a standard that applies only to a part of your application, but it must be a global decision. By using microservices, we create several smaller applications with very limited functionality. For example, we can have a service whose responsibility is to act as a container to chat with an external API. Services must be weakly connected: there are no direct connections between services or cross-talk between services. Services must have their own data storage solution that is not shared with another service. This means absolutely no integration at the database level! Finally, there should be no dependencies between the services at the time of implementation.

Setting limits between services in a microsystem cluster is a difficult problem. There are many ideas around it, but most of them revolve around domain-oriented design.

Different challenges of a monolith

Although there are many advantages in a microservice approach, there are also disadvantages. The monoliths are implemented as a single entity in one or more servers, each of which obtains the same code. This unique implantation is a curse and a blessing. Unique implementations mean that you have fewer moving parts in the creation and deployment pipeline. There are no concerns about data transport between various applications or discovering the limits for these applications. The most important advantage for this article is that the registration in the registry resides in only one location.

The log is a perfect example of a transversal concern: code that needs to cover several modules at different levels of the code base. When we divide our application into silos, the record is also divided into all services.

A single logging technology

A much discussed benefit of microinsurance is that each service can be written using appropriate technology. A component that does a lot of mathematics may not be as efficient written in JavaScript as in Go. Microservices allow you to select a technology that best suits each component. Generally, each microservice is built by a team specialized in the technology used in that service. Reinforcing a single data logging technology is a challenge to the microservice mentality. However, this is a time when it is justified to go back in academic perfection in favor of pragmatism.

A shared logging implementation for every service

A single registration technology provides us with a location for the records, regardless of which service originates the registration message. If we are trying to find a network problem, we do not want to have to go through several log files located all over the place to see what services have been affected. Ideally, we want to have a one-stop-shop that allows searching, classifying and designing registration information for several dozens of services. The technologies that allow this, registry aggregators, tend to have connectors for several languages. For example, Stackify Retrace has connectors for Java, .NET, PHP, Ruby and Node.js out of the box, as well as a Restful API that unlocks almost all other languages.

The errors can cover several microservices, so the registry as our best tool to track errors must also cover them.

A logging technology which allows queries

A single user interaction in a microsystem architecture can encompass many services. Being able to accompany a user interaction is much easier if you have a registration tool that allows you to use an advanced query language to search, design and add. The registration in aggregate can also be very useful. Queries like this one are super-valuable: “what percentage of requests for X service results in errors?”, Or “what time of day do we see the biggest load on the system”, or even “what is the average time that an application spend? in the X service. ”

Naturally, there are many registry aggregators out there, and choosing one that has an advanced query language is a good differential. Another aspect to consider is how easy it is to see the data after writing a query for them. A good chart will give you background information that are difficult to analyze from a record message.

Next, there is an example of a Retrace panel showing several important metrics, some of which are extracted from record searches.

Interested in learning Java? Join now:” java training in chennai “

Use a correlation identifier

When a client contacts you with a problem you had in your application, it is very good to be able to quickly find what has gone wrong. One method to do this in a micro security application is to include a correlation or transaction ID in each message. Fill this field with an ID removed from the initial event. Consider a scenario in which a user creates an account. This can trigger actions in the user’s service, in the customer loyalty service and in the billing service.

By having a unique identifier that is disconnected by each of these services while processing a message, it is easy to find the creation flow of the user. All that is needed is to pop the unique identifier in the search engine of the record aggregator and get all the registration messages related to that transaction. You can even present the user with that correlation ID, if something goes wrong, so you have a reference number to quote when talking to your support organization; This is even more useful if you are the support organization.

Interested in learning Java? Join now:” java training in bangalore “

Include a lot of information

It is much more common that you want to have more information recorded than less. Obviously, there are some performance and storage considerations in relation to over-registration, but very small registration can lose the main information forever. Including context information in your log messages increases the chances that you can track problems. For example, it usually improves my log messages with information such as:

service name that generates the registration message
Correlation ID
username that triggered the action
machine name or container id
date of receipt of the message in UTC
date of sending the message in UTC
entire body of the drive message

Carefully consider what information would be useful in debugging problems and you would be wrong to include too much. If you are using a registration structure that supports structured registration (which is excellent), you can place all this information in the properties of the logging message and not overload your actual messages.

November 23, 2018 0

Java EE Overview

In this article, you will find information about the history of the Java EE ecosystem: where it came from and how it has changed in recent decades. You will discover the main milestones in its development, from J2EE 1.2 to its current incarnation Java EE 7, and we will see in the future what Java EE 8 has reserved.

You will discover how to get involved with the development of the platform itself and how to enter JCP.org to make an even greater contribution. Find out about the Java EE Guardians and how you can support the development and growth of the platform.

What is Java EE?

Java EE consists of a set of more than 28 specifications and a runtime environment. It is a superset of the Java SE platform. This means that Java EE components can take full advantage of all Java SE APIs.

This set of APIs creates multilayer applications based on standard components and implements in different containers, offering a variety of services. It is not only used to develop monolithic application structures, but also structured applications of microsystems. More information about Java EE and microservices checking Java EE and Microservices in 2016? You are interested in the development of tip in the space of microservices with respect to Java EE? Next, visit the Eclipse Microprofile project website.

The Java EE programming model has annotations to specify settings instead of XML description files and uses the configuration convention to help you start using the least possible ceremony.

It has its own contextually conscious dependency injection structure at the center of its programming model.

History of Enterprise Java

In 1998, the first incarnation of Enterprise Java was launched, but then important technologies soon joined the mix, such as Servlets, Messaging and Enterprise Java Beans.

These technologies still exist on the Enterprise platform today, but in a much more advanced and complete way.

In the following years, he developed a programming model that was difficult to use and very complicated. All this changed in the fifth edition, which saw a radical change of the XML configuration towards the notes and convention about the configuration.

The new programming model has been substantially simplified. Annotations replace the XML description files, the configuration convention replaces the tedious manual configuration, and dependency injection hides the creation and search for resources. Resources are created and injected into injection points marked by annotations such as @Inject. Therefore, all you need is a POJO that meets the conditions of the managed beans specification, JSR 299 and, depending on the annotation used, it will become an EJB, Servlet, Singleton or RESTful Web service.

The platform continued to grow, but at a much slower pace. To each new version, it becomes more friendly to the programmer and the number of APIs grew to reach 28+, above only a handful of five APIs in 1999.

Interested in learning Java? Join now:” java training in chennai “

What comes in Java EE 8?

Oracle is moving the focus of Java EE to microservices and the cloud, and the next version of Java EE will include the APIs that complement this new address.

As well as advances in some established technologies, such as Bean Validation, Context Injection and Dependency, JavaServer Faces, JAX-RS (RESTful web services), JSON-Processing and Servlets, there will be two new APIs.

JSON-binding, a dedicated security API and security API for Java EE, designed to standardize security.

The Java EE 9 will see even more APIs designed for the development of microsis and cloud-based applications.

Interested in learning Java? Join now:” java training in bangalore “

Java Community Process (JCP)

The development of the Java EE platform occurs through the Java Community Process (JCP), responsible for all Java technologies.

The group of experts consists of interested parties who created Java specification requests (JSR) to define the various Java EE technologies. All done in cooperation with the international community of Java developers.

The work of the Java community under the JCP program helps to guarantee the stability and compatibility standards between Java technology platforms.

Anyone can review and comment on draft specifications and JSR proposals, as well as read the JCP blog. Anyone can register as user

Anyone can review and comment on draft specifications and JSR proposals, as well as read the JCP blog. Anyone can register as a user of the site and can be authorized as a member of the Collaborator or the Group of Experts. You can become a JCP member and make an even greater contribution. Go to the link to discover more.

November 22, 2018 0

6 Types of ROI for APM (Application Performance Management Tools)

6 Types of ROI for APM (Application Performance Management Tools)

It has been said that almost all companies are now a software company in some way or another. This means that the reliability and performance of your software applications are critical to your success. Unfortunately, many application performance management (APM) tools have been very expensive and only target large companies.

The price of the APM for 20 servers can vary from US $ 500 to US $ 6,000 per month. Some providers also require that they be paid annually. It is common to hear from customers who may experience our product, Retrace, for a few hundred dollars a month or to pay another supplier of US $ 25,000 and who are stuck in an annual contract.

APM solutions can be accessible and have an invaluable return on investment (ROI) if they are used to their full potential. In this article, we will discuss some of the main benefits of APM and how they provide excellent ROI.

Examples of APM ROI and other benefits

Increase in developer productivity

Software developers are expensive. They are also a highly limited resource in today’s economy. It is important to keep them working on innovating new products that can expand their businesses. The development tools that make them more productive are very valuable.

Solving production problems can be very difficult and delayed. APM tools are designed to help developers quickly identify application problems.

If the APM can save its developers for a few hours a month, it’s easy to see how quickly it pays. The ZeroTurnaround developer’s productivity report showed that the average developer spends at least a few hours a week firefighting production problems.

Prevention of application problems

The sooner an application problem is identified and corrected in the development life cycle, the less time and money will be necessary. In a perfect world, we would all like to find all the problems of the application while the developers are writing the code or the quality control.

Tools like Prefix and Retrace can do exactly that. The prefix is free and the Retrace is only US $ 15 per month per server in quality control. It is very difficult not to justify these costs if it can help identify problems before they reach production.

It is easy to understand that finding errors when writing code or in quality control is much easier to fix than in production. A simple production error can also cause tens or hundreds of support problems with your customers. The last thing you want to do is overload your support or sales teams with the management of boring customers.

The cost of downtime

Another day I ordered pizza at the Pizza Hut site. If your website was slow or down for any reason, you could easily order pizza from a dozen other companies. Every minute that your site is down has a big impact on your sales for the day and your bottom line.

Delta Airlines had an interruption of 5 hours in August 2016. Problems with the computer forced us to cancel about 2,000 flights. They reported that it cost them 150 million dollars. British Airways and Southwest also had disruptions last year that caused them a lot of money.

Proactive application monitoring can help identify problems before they become worse. To find slow SQL queries to identify high volume requests that must be optimized.

Being able to quickly identify the root cause of a problem can drastically reduce the average repair time (MTTR).

Performance as a resource

Keep in mind that performance is also a feature of your application. Users love software fast. This creates a larger overall feel for your product. It can be difficult to quantify, but it helps in conversions and customer retention.

Slow performance can affect your profitability. Amazon found every 100ms of latency cost them 1% in sales. We can all relate to trying to buy something online and stop because it was taking too long.

Children may be screaming, it’s time to go to dinner or some other reason. Sometimes, we tell ourselves that we will see later when we have more time. Many times we do not remember or spend our money on something else. “I almost bought one of those” is the last thing any retailer wants to hear.

One of our clients offers small loans for their clients online. Your site was taking 10 to 15 seconds to load and I could not understand why. They managed to use the Retrace to identify that the caching did not work correctly.After applying the fix, they were immediately able to see a substantial increase in business.

Interested in learning Java? Join now:” java training in chennai “

5. Reducing Hosting Costs

APM products are very useful for measuring the performance of your applications and help identify opportunities for improvement. A SQL query fits here, some code refactoring, and you can reduce your hosting costs through some optimizations.

For example, in Stackify, we had an application that worked on about 20 servers. Using the Retrace to identify possible performance optimizations, we managed to refact some codes and reduce the number of servers by 50%. This simple change saved us $ 2,000 a month.

APM tools can help you understand how your applications use SQL databases, Elasticsearch, Web services and much more. We’ve heard all the time from customers who had no idea how many SQL queries the application runs or how slow the queries were. A bit of performance tuning around application dependencies can improve overall performance and allow you to reduce these dependencies.

Interested in learning Java? Join now:” java training in bangalore “

SLA requirements

Many B2B companies have service level agreements (SLAs) with their partners. These agreements generally have clear written penalties if the software is not online and works properly.

A brief interruption of Amazon AWS in February 2017 will cost you 2% of your total income due to the SLA credits. A small interruption of 5 hours would probably cost millions in revenue. Their interruptions caused problems for many customers, including Apple, Adobe and Netflix.

Amazon would have to reimburse 10-30% in service credits. Many providers offer service credits based on how poorly the SLA has been lost. Here is an example of a table that defines how an infraction in the SLA is treated.

Conclusion

In this article, we discuss some of the ways in which APM tools provide very high ROI. They can help with developer productivity, avoid problems with applications, reduce hosting costs, optimize performance and avoid costly downtime.

More importantly, APM tools can help you sleep at night.

They help you proactively monitor the performance of your applications 24 hours a day. They are also there when you need to get in and quickly solve a problem.

The price and functionality of APM tools vary widely. See our list of APM’s top 10 critical resources. You may also want to read about the accessibility of APM products and how they are accessible to smaller companies.

Application monitoring tools do not have to be too expensive. The goal of Stackify from the first day was to create an affordable and holistic suite of application monitoring tools. Retrace combines lightweight code profile, application errors, logs, metrics and much more in an easy to use tool for developers.

November 21, 2018 0

4 Types of Java Logs

Log is an important issue in software development, especially if you need to analyze errors and other unexpected events in your production environment. Implementing your registry usually seems easy. But, as you have probably experienced, the creation of log is much more complex than it seems. As an experienced developer, you should know the different Log structures available, the common pitfalls and best practices and, of course, the types of log files used in common deployment scenarios. In this article, I will focus on the last part. I’m going to talk about 4 different types of logs that you can find in almost every development or production environment.

Application Log

Let’s start with the most common type of Log: application log

Most developers think about that record when talking about the registry. The reason for this is simple. Your application produces this record. It contains all types of error messages, warnings or other events recorded by the application. These messages can provide high-level logical information connected to specific use cases. Typical examples are:

The stacktrace of an exception that occurred in a use case.
Warning messages about slow response times from an external system.
Information that a use case has been triggered or terminated.

The application record is probably the most important type of record that is mentioned in this article because you have full control over it. This means that you are responsible for writing the messages.

Each log message must provide useful information that helps you understand the behavior of your application. If you want to know more about application logs, take a look at Eric’s article, which describes an optimal set of best practices for registering applications.

Web server logs and applications

The next interesting and important type is the Log of your web server or applications.

Most business applications are implemented on a Web server, for example, Apache Tomcat or an application server, for example, Wildfly or WebSphere Liberty. Your log files provide information about technical problems and the current status of the server.

The configuration and resources of each server are different, and I will not explain them in detail in this article. But, please be sure to check the documentation of your server and configure it properly. Obtaining the correct information from your server can make the difference between identifying potential problems over time and a server unavailability.

Garbage collector Log

The garbage collector provides automatic memory management. It controls all the objects instantiated in a JVM and eliminates those that are no longer used. This is a very complex task and there are several different garbage collector implementations available.

In general, the garbage collection process in Java is very efficient. It is so efficient that there are many applications that use the default implementation with their default settings. But if your application has to handle high load or use many complex object structures, the performance of the application may decrease over time. This usually happens when the garbage collector needs to spend more and more time to manage the available memory. The garbage collector record provides the necessary information to analyze all the activities of the garbage collector.

The garbage collector log is disabled by default. You must enable it with a set of command line properties.

If you are using JDK 8 or earlier, you can do so using the following properties:

-XX: + PrintGCDetails -Xloggc:

From JDK 9, you must use the following properties:

class = “prettyprint” -Xlog: gc *: file = <path of file-del-gc-log>

After starting your application with these command line properties, your garbage collector will record detailed information about all the operations. Unfortunately, the content and format of the garbage collector log generated depend on the provider and the version of your JVM and the garbage collection algorithm.

System Logs

All the logs discussed above are written by JVM or a running application in JVM. In addition to these records, you must also be familiar with the Log recorded by your operating system.

As a Java developer, I probably never write in these logs. But your operating system logs certain events in these registers. Other applications, which are part of its implementation, can also do so. Therefore, system records are a good place to get an overview of external events.

If you are running your application on Windows, this is the event log. In Linux, you must know the syslog service and its successors.

Windows Log wvent

The Windows event log contains important hardware and software events in the categories, security, configuration, system, and forwarded events applications.

Especially the application events and the system category can be useful to understand the events that have occurred outside of your application. The application category contains events reported by other applications that run on the local Windows system. The events related to the hardware and the controller belong to the system category.

Interested in learning Java? Join now:” java training in chennai “

Linux system Logging

The Linux syslog service and its successors provide a highly configurable registration system. It Log messages triggered by applications or by the operating system in a file or sends them to a remote system.

The Log service used and its configuration depend on your Linux distribution. Please check the documentation to know more about your specific operating system.

Interested in learning Java? Join now:” java training in bangalore “

Conclusion

Logging is an important issue with many different facets. In this article, I have summarized 4 important Logs that you should know as a Java developer:

The log of the application is the most obvious. It is written by your application and you are responsible for the content.
If you deploy your application to a Web or application server, you will also need to know the Logs provided by that server.
Garbage collector Logs can provide important information if you need to analyze performance problems.
You can check the system logs to get an overview of all external events that may have affected your application and cause the service incident.

November 17, 2018 0

Java performance tools

Performance tools for Java

Accompanying the performance of your application is a continuous task, so it is important to have the right tools. What works in the development may not be so useful in a production environment. Here, I’m going to talk about the best tools and the best time to use them. The goal is to help you create reliable, high-performance applications as quickly as possible.

1. Java Profilers

JVM profiles offer a ton of raw data by tracking all method calls, allowing you to find CPU access points and memory consumption. A good test of size is to configure an Apache JMeter job to reach an endpoint that is developing a few thousand times while it is linked to a profile creator. This allows you to specify the memory and CPU requirements for production.

Pros: optimal for tracking memory leaks, the ability to manually run the garbage collection and then review the memory consumption can easily highlight the classes and processes that are kept in memory by mistake.

Cons: Requires a direct connection to the monitored JVM; This ends up limiting the use to development environments in most cases. (Note: some profile creators can work with subprocess frames and memory in limited ways).

2. Tracking web requests and transactions in Java

The standard profile creators focus on the performance of all methods throughout the application. These tools focus on the performance of individual requests or transactions on the web.

The prefix provides deep-level performance details about your application. Including ORM calls with generated SQL, SOAP / REST API calls and tracking details of the most used third-party libraries and structures.

XRebel is configured by a Java agent in the container of the web application and provides an overlay in the application that provides details about the current request.

Pros: these tools give order to the large amount of data available in a profiler of the JVM. By helping you track the flow of a request, you can see what types of method calls are responsible for your response time.

Cons: Designed only for the development cycle. The quality control and production environments require an APM solution.

3. Java Application Performance Management (APM)

Application performance management (APM) tools assume the task of tracking all requests in a production system. The trick of these proflets is to provide the correct information intelligently so as not to impact production performance. This is done by adding time statistics and sampling traces. This gives you visibility of the level of the method for your code that is running in production.

Pros: The ability to monitor your most critical environment: Production. Identify the problems before going into production, monitoring the QA / Staging. Debug production by analyzing traces and exceptions. Summaries added to see highly used requests to help focus development time.

Cons: normally expensive to run on all the quality control / preparation and production servers. Some tools do not support asynchronous queries or do not fit correctly and slow down your application.

4. Real user monitoring (RUM)

It is not uncommon for webapps to be very dependent on the client’s side; The provision of an interactive experience may require many dependencies, such as JavaScript / CSS structures, Web sources and images.

RUM provides information on the dependencies of your application, giving visibility to the download of resources and the time of representation of the page.

Some APM products include this as an additional resource. There are also independent products, such as Google PageSpeed.

Performance Metrics of the JVM

JVM provides a wealth of valuable information, such as garbage collection, memory usage, and thread counts. This data is available through JMX.

Stackify Retrace provides monitoring of JVM metrics through application monitors and automatically applies intelligent patterns based on the type of application discovered.

Pros: Available in any application that runs in JVM and easy to connect with applications such as JConsole.

Cons: It can be difficult to connect in a preparation and production environment. Aggregation and comparison of data can be time consuming. The statistics are collected only while the monitor is connected to the JVM.

Access logs to the Web server (Apache / Nginx)

If you have Apache or Nginx proxy requests for your Java application server, you can monitor the access records. This is a quick way to see how long applications are being made. You can add access logs to see which are the most popular / fastest / slowest endpoints. Doing this through the command line may take, however.

For small data sets, you can use a desktop tool such as Apache Viewer, but for preparation and production environments, a hosted registry solution is ideal.

The tracking of failed requests is also very useful, which can be done by aggregation in HTTP response codes.

Pros: quick way to get some simple statistics, by following the access records, or – if more information is needed – push a log analyzer.

Cons: does not provide details about why the request took so long. There is a lack of POST data and response content that can help pinpoint the cause of a performance problem.

Interested in learning Java? Join now:” java training in chennai “

Accompanying all Java exceptions

One of the biggest causes of performance problems may be application exceptions. When an exception is thrown, it causes the segment to stop while collecting the stack trace. Even manipulated exceptions that seem innocent can cause huge performance bottlenecks under heavy server load. It is important to add and monitor all your exceptions to find critical problems, new errors and monitor error rates over time.

More information: How GWB found hidden exceptions and application performance issues

Pros: Easy to configure, if you are using a registration structure, such as Log4j or Logback.

Cons: None

Interested in learning Java? Join now:” java training in bangalore “

Memory analysis

The memory analysis of the application after a failure can help identify the cause of a memory leak. You can instruct JVM to dump the heap in an OutOfMemoryErrorexception including the following argument in JVM:

-XX: + HeapDumpOnOutOfMemoryError

The heap dump file can be loaded into an analyzer – Eclipse MAT. You can immerse yourself in the Overview or Leaks Suspects reports to help identify the cause of the memory exception.

Conclusion on Java performance tools

The big conclusion is that creating and maintaining the performance of the Java application is easier than ever with all these tools. Do not be overloaded with all the things you should do. Start with the fruit hung first, as a follow-up to the exception. It is really good, at least, to know what options are available to you, and I hope you have found this list useful.

November 15, 2018 0

How to monitor Java services – performance, errors and much more

In the real world, a lot of mission critical business logic lives in background services. Buying something from an e-commerce site, such as Amazon, initiates a variety of tasks that must be completed after clicking to confirm your request. Monitoring the performance of your web applications is only part of the puzzle if you want to proactively ensure that your software is working correctly all the time.

If you want to make sure that your software is working properly, you should monitor your Java services that deal with these mission critical tasks in the background.

Why monitoring a Java service is different

Monitoring of Java Services is different from monitoring of Java web applications. Web applications have very defined “transactions” based on each Web request that is running in the application container. It is very simple that services such as the Retrace identify each request of the individual Web and accompany the performance of them.

Java services are not started or defined for the work they perform. They usually start and run continuously until the server shuts down. To properly monitor the performance of your Java services, you must define the start and end of the transactions or the operations that are executed.

Identifying “Operations” in your Java services

Java services generally follow several commonly used standards. By identifying these patterns, you can quickly assess the best way to identify operations in your code.

Think of an operation as a small unit of work that is repeated several times. You need to identify which of them you want to monitor in your code.

Common standards of use:

• Queue listener: the application listens continuously in a queue and each message captured in a queue would be an exclusive operation.

• Timer-based – Many Java services use timers to repeat a specific operation at intervals of a few seconds, such as searching a database.

• Job scheduler: it is possible to incorporate a task scheduler such as Quartz in your Java service to trigger small jobs and scale them on all servers.

Most Java services will probably execute several operations. I would suggest dividing them into the smallest logical units of work. It is better if you supervise smaller work units. This is similar to monitoring each web application in your web application compared to monitoring the performance of the web application in its entirety.

For example, our monitoring agent for Linux is a Java service. He makes a ton of different operations on a schedule every few seconds. Each of these tasks that you execute must be defined as exclusive operations so that you can follow everything you do.

How to Instrument “Operations” in Your Code for Retrace

After identifying the operations you want to accompany, you will need to make some smaller code annotations to define your operations. This is done by adding the dependency of the Stackify Java APM annotations to the pom.xml file of your project.

<dependency> <groupId>com.stackify</groupId> <artifactId>stackify-java-apm-annot</artifactId> <version>1.0.4</version></dependency>

Example of instrumenting your code for Retrace:

import com.stackify.apm.Trace; @Tracepublic class ClassToBeInstrumented{ @Trace(start = true) public void methodToStartNewTrace() { … }}

How to install Retrace for Java Services

The Retrace uses the lightweight Java profile and other data collection techniques. A service is installed on your Linux server and runs in the background. Our agent is easily installed by means of a curl or wget command. Please, check our documents for complete instructions.

Retrace provides developers with many advantages for monitoring Java service performance. Retrace provides holistic monitoring of Java service performance, including code profile, errors, logs, metrics and much more.

Benefits of monitoring Java services with Retrace

Once your code has been instrumented and the Retrace is collecting data about your Java service, you can get some incredible details about what your code is doing. Retrace can monitor independent Java applications executed through various service managers.

Retrace automatically supports dependencies and the most common Java frameworks, without code changes. You can instantly see how they are used in your application and how they affect performance. This includes PostgreSQL, MySQL, Oracle, external web services, MongoDB, Elasticsearch, Redis, Quartz, Hibernate and much more.

Identifying the main operations

Retrace allows you to see all the operations that are running in your Java service. Quickly identify the frequency with which each of them runs, the average time of execution and much more. The performance of Java services is typically a “black box.” Retrace allows you to understand exactly what your Java service is doing.

Tracking Top SQL Queries

Retrace automatically crawls all SQL queries executed by your code. This includes stored procedures, dynamic SQL, Hibernate queries with crazy appearance and much more. Quickly identify which queries are running, how long they take and how often they are being called.

View Application Exceptions & Logs

Because Retrace works through the Java light code profile, it also has the ability to collect untreated exceptions by being thrown by its code. You can also track exceptions that are recorded in your registration structure.

Retrace provides powerful functions for error monitoring and record management. You can send all your records to the Retrace via log4j, logback and others. With Retrace, you can search all your records in a single location and perform many other advanced records management features.

Interested in learning Java? Join now:” java training in chennai “

Tracking Custom Application Metrics

Retrace automatically monitors the use of the CPU and the memory of your Java service. You can also use it to track many other JMX standard MBeans. Including statistics on garbage collection and exceptions are counted per second. Retrace can also monitor custom JMX mBeans created by your applications.

The custom metrics are also compatible with the use of Stackify’s maven “stackify-metric” package. With just a few lines of code, you can accompany how often or for a long time your Java service does practically anything.

Interested in learning Java? Join now:” java training in bangalore “

View Code Level Traces

One of the most powerful features of Retrace are the snapshots of the level of code that it collects. For any of the operations tracked for your Java service, you can see all the main methods, dependencies that are called, exceptions, records and much more in context.

Summary

The developers depend a lot on Java services to do a great job of mission critical. Monitoring Java services is essential to ensure that they are functioning correctly and with good performance.

Retrace is an excellent solution to monitor the performance of your Java services. For more information, see our product page on Retrace and our overview of application tracking.

November 14, 2018 0

Java Profiler List: 3 different types and why you need all of them

Debugging performance problems in production can be a pain and, in some cases, impossible without the right tools. The Java profile creators have been around for a while, but the profile creators that most developers think are just one type.

Let’s dive into the 3 different types of Java profiles:

Standard JVM profiles that track all the details of the JVM (CPU, chaining, memory, garbage collection, etc.).
Light profilers that emphasize its application with a little abstraction.
Application performance management (APM) tools used to monitor live applications in production environments.

Standard JVM profiles

Products such as VisualVM, JProfiler, YourKit and Java Mission Control.

A standard Java profiler certainly provides most of the data, but not necessarily the most useful information. This depends on the type of debugging task. These profiler will track all method calls and memory usage. This allows a developer to immerse themselves in the call structure at any angle they choose.

pros:

Excellent for tracking memory leaks, standard profiles detail all memory usage by JVM and which classes / objects are responsible. The ability to manually run the garbage collection and then review the memory consumption can easily highlight the classes and processes that are retained in memory with error.
Good for tracking CPU usage, a Java profile creator generally provides a CPU sampling resource to track and add CPU time per class and method to help focus on access points.

cons:

Requires a direct connection to the monitored JVM; This ends up limiting the use to development environments in most cases. (Note: some profile creators can work with subprocess frames and memory in limited ways).
slow down your application; Good processing power is necessary for the high level of detail provided.

Interested in learning Java? Join now:” java training in chennai “

Lightweight transaction profiles in Java

Products such as XRebel and Stackify Prefix.

The creators of light profiles adopt a different approach when tracking their application, injecting themselves directly into the code.

Aspect Profilers uses aspect-oriented programming (AOP) to inject code at the beginning and end of the specified methods. The injected code can start a stopwatch and report the elapsed time when the method is completed. These profiler are simple to configure, but you need to know what to create. For example, see Creating the profile of the Spring AOP method.
Java Agent profile creators use the Java instrumentation API to inject code into their application. This method has greater access to your application, since the code is rewritten at the bytecode level. This allows any code that runs in your application to be instrumented – either the code you wrote or the third-party libraries that the application depends on. Check the introduction to the Java agents to see how everything works.

Aspect profilers are very easy to configure, but they are limited in what they can monitor and are overloaded by detailing everything you want to track. Java agents have a great advantage in their tracking depth, but they are much more complicated to write.

The Stackify Prefix is a developer-oriented Java profile creator using the Java agent profile method behind the scenes. The interesting thing is that Prefix already knows the most desired classes, and developers of third-party libraries want to be instrumented. So you do not need to detail all of them. In addition, it takes all the instrumentation statistics and displays them in a simple and understandable way. For example, when running an application using Hibernate, the Prefix not only details the elapsed time for queries, but also displays parameter values for the generated SQL. When your application calls a SOAP / REST API, the Prefix provides the content of the request and the response.

Interested in learning Java? Join now:” java training in bangalore “

Low Overload, Creating Java JVM Profile in Production (APM)

APM tools like New Relic, AppDynamics, Stackify Retrace, Dynatrace.

All profilers have been optimal for development so far, but monitoring how your system works in production is critical. Production is always a different landscape – the development and preparation configurations usually do not have the same data sets and load.

Java APM tools generally use the Java Agent profile creator method, but with different instrumentation rules to allow execution without affecting performance in productions. The trick with these proflets is to provide the correct information in a smart way so as not to occupy the CPU cycles.

Why are some Java profiles so expensive?

XRebel is a legal tool, but it costs US $ 365 per year. The Stackify Prefix is free and provides much of the same functionality.

The biggest problem with APM solutions is definitely its price. Traditionally, they are so expensive that only the largest companies can deal with them. It does not make much sense to spend $ 100 a month on a server in Azure or AWS and spend another $ 200 a month for a product like the new relic.The monitoring tools should not cost more than the servers!

November 12, 2018 0