Execute ready made growth recipes for your business to get more customers, grow your audience and engage using the best email marketing platform

Simplifying Marketing and Growth using Premade templates and ...

We are your growth partners in technology and No-code who help with web development, app development, automations and integrations along with technology consulting.

Best Product and app development firm to help any business with ...

Bad UX that increases support requests ... word-of-mouth. Companies who fix CX blind spots can gain happy, loyal customers and often add tens of thousands directly to the bottom line. #uxdesign #cx #userexperience #userexperiencedesign #grorapidlabs #uiux...

GroRapid Labs | LinkedIn

Grorapid is a marketing tool that simplifies smart marketing for small businesses. They provide ready to execute marketing tactics and content across different channels, enabling people to market like pros and take their business to the next level.

Grorapid - Crunchbase Company Profile & Funding

&quot;At Grorapid Labs, we believe in developing software with the use of modern technology and user-friendly design to offer solutions that exceed the client&#x27;s expectations. Whether you&#x27;re a startup that wants to develop a transforming app or an established organization looking to better optimize ...

Grorapid Company Profile, information, investors, valuation & Funding

Working with Grorapid Labs on our CRM solution was definitely a good decision for our company. Their customized approach and in-depth knowledge of our procedures resulted in a system that not only streamlined our operations but also gave actionable insights. The degree of dedication and attention ...

GroRapid labs - We are product engineers

You need to enable JavaScript to run this app

Grorapid - Marketing SaaS Product | Company Page | IndieFolio

View Grorapid revenue, competitors and contact information. Find and reach Grorapid&#x27;s employees by department, seniority, title, and much more.

Grorapid - Overview, Competitors, and Employees | Apollo.io

Check Grorapid Labs Private Limited registration details online. Get financial highlights, company network &amp; industry details. Sign Up now for more reports &amp; updates

GRORAPID LABS PRIVATE LIMITED - Company Profile, Directors, Revenue ...

Grorapid: Grorapid provides ready to execute industry-specific marketing campaigns. View company info, jobs, team members, culture, funding and more.

Grorapid | AngelList Talent

Apply to 1 jobs at Grorapid. Apply for new Grorapid job vacancies online at Cutshort.

1 Grorapid Jobs in India | Grorapid careers | Cutshort

Marketing platform for webpages, email marketing and lead generation using forms and popups

Grorapid Help Center

Grorapid Labs is a NoCode development company that builds websites, webapps, prototypes, automations and integrations at a blazing speed with NoCode tools.

Best NoCode Agency to build No-code projects in just weeks - NoCode ...

Get your technology challenges resolved with No-code, Integrations or Custom development · No results for your search, please try with something else

Grorapid

Grorapid is hiring - see 6 jobs. Grorapid provides ready to execute industry-specific marketing campaigns

Grorapid Jobs

We make it easy for marketers and entrepreneurs to create and execute lead generation and lead engagement campaigns by providing ready to use industry-specific packages, built on top of an execution platform

Real-Time Event Monitoring with Redpanda, OpenTelemetry, and Grafana

Using pgvector To Locate Similarities In Enterprise Data

এন্টারপ্রাইজ ডেটাতে মিল খুঁজে পেতে pgvector ব্যবহার করা

Verwenden von pgvector zum Auffinden von Ähnlichkeiten in Unternehmensdaten

Uso de pgvector para localizar similitudes en datos empresariales

Utilisation de pgvector pour localiser les similitudes dans les données d'entreprise

एंटरप्राइज़ डेटा में समानताएँ खोजने के लिए pgvector का उपयोग करना

pgvector を使用して企業データ内の類似点を特定する

pgVector를 사용하여 기업 데이터의 유사점 찾기

Usando pgvector para localizar semelhanças em dados corporativos

Использование pgvector для поиска сходств в корпоративных данных

Kurumsal Verilerdeki Benzerlikleri Bulmak İçin pgvector'u Kullanma

Sử dụng pgvector để xác định điểm tương đồng trong dữ liệu doanh nghiệp

使用 pgvector 查找企业数据中的相似之处

What is Authentication? 🔐 Authentication is the process of verifying the identity of users, ensuring they are who they claim to be before granting access to a system or application. In the context of web applications, this is crucial for protecting sensitive information and resources. Authentication involves: User Credentials:🔑 Users provide credentials, such as usernames and passwords. Verification Process:✔️ The system verifies the provided credentials against stored data. Successful verification grants access; otherwise, access is denied Spring Security🍃 For developers building Spring-based applications, Spring Security serves as the de-facto standard for securing their creations. This comprehensive framework provides robust authentication and authorization mechanisms, ensuring your application’s data and functionality remain safe from unauthorized access. Java JWT (JSON Web Token)Authentication: A Secure and Scalable 🔐📈 Approach JWT stands for JSON Web Token, a self-contained token that contains information about the user and is signed by the server for verification. It has become a popular choice for authorization due to its numerous advantages. Use Cases: JWTs are widely used in various scenarios: Public APIs: Securely access public APIs without requiring frequent logins. Mobile Applications: Store user information and authorization details within the token for offline use. Single Sign-On (SSO): This allows users to seamlessly access multiple applications with a single login. Practical application of JWT by implementing it in a Spring Boot application to secure our API endpoints⛏👷 Now, we will configure the in-memory user and JWT. We will create an API endpoint and secure it using Spring Boot security. Create a Spring Boot Project Use Spring Initializr to create a new Spring Boot project with the following dependencies: For Web: <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
</dependency> For Security <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-security</artifactId>
</dependency> Lombok: <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
</dependency> For JWT: <dependency>
 <groupId>io.jsonwebtoken</groupId>
 <artifactId>jjwt-api</artifactId>
 <version>0.11.5</version>
</dependency>
<dependency>
 <groupId>io.jsonwebtoken</groupId>
 <artifactId>jjwt-impl</artifactId>
 <version>0.11.5</version>
 <scope>runtime</scope>
</dependency>
<dependency>
 <groupId>io.jsonwebtoken</groupId>
 <artifactId>jjwt-jackson</artifactId> 
 <version>0.11.5</version>
 <scope>runtime</scope>
</dependency> Let’s start with creating an endpoint to be secured: @RestController
@RequestMapping("/home")
public class Controller {
 @Autowired
 private UserService userService;
 @GetMapping("/users")
 public List<User> getUsers(){
 System.out.println("getting users");
 return userService.getUsers();
 }
} Create a user: @Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class User {
 private String userId;
 private String name;
 private String email;
} Create a service class: @Service
public class UserService {
 private List<User> store=new ArrayList<>();
 public UserService() {
 store.add(new User(UUID.randomUUID().toString(), "Bhushan", "bhushan@gmail.com"));
 store.add(new User(UUID.randomUUID().toString(), "Ramesh", "ramesh@gmail.com"));
 store.add(new User(UUID.randomUUID().toString(), "Suresh", "suresh@gmail.com"));
 store.add(new User(UUID.randomUUID().toString(), "Paresh", "paresh@gmail.com"));
 }
 public List<User> getUsers(){
 return this.store;
 }
} Create an in-memory user with UserDetailService bean: @Configuration
public class AppConfig {
 @Bean
 public UserDetailsService userDetailsService() {
 UserDetails userDetails = User.builder().
 username("Bhushan")
 .password(passwordEncoder().encode("Nemade")).roles("ADMIN").
 build();
 return new InMemoryUserDetailsManager(userDetails);
 }
 @Bean
 public PasswordEncoder passwordEncoder() {
 return new BCryptPasswordEncoder();
 }
 @Bean
 public AuthenticationManager authenticationManager(AuthenticationConfiguration builder) throws Exception {
 return builder.getAuthenticationManager();
 }
} Start with creating the class JWTAthenticationEntryPoint that will be implementing : Used to handle authentication-related exceptions. Specifically, it is responsible for returning an unauthorized (401) response to clients who attempt to access protected resources without proper authentication. AuthenticationEntryPoint @Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
 @Override
 public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException)
 throws IOException, ServletException {
 response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
 PrintWriter writer = response.getWriter();
 writer.println("Access Denied !! " + authException.getMessage());
 }
} The helper class is often created to encapsulate the logic related to the generation, parsing, validation, and manipulation of JWTs in a more modular and maintainable way. It provides a set of methods and utilities to interact with JWTs. Create a JWT helper class: @Component
public class JwtHelper {
 public static final long JWT_TOKEN_VALIDITY = 5 * 60 * 60;
 private String secret = "afafasfafafasfasfasfafacasdasfasxASFACASDFACASDFASFASFDAFASFASDAADSCSDFADCVSGCFVADXCcadwavfsfarvf";
 public String getUsernameFromToken(String token) {
 return getClaimFromToken(token, Claims::getSubject);
 }
 public Date getExpirationDateFromToken(String token) {
 return getClaimFromToken(token, Claims::getExpiration);
 }
 public <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {
 final Claims claims = getAllClaimsFromToken(token);
 return claimsResolver.apply(claims);
 }
 private Claims getAllClaimsFromToken(String token) {
 return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
 }
 private Boolean isTokenExpired(String token) {
 final Date expiration = getExpirationDateFromToken(token);
 return expiration.before(new Date());
 }
 public String generateToken(UserDetails userDetails) {
 Map<String, Object> claims = new HashMap<>();
 return doGenerateToken(claims, userDetails.getUsername());
 }
 private String doGenerateToken(Map<String, Object> claims, String subject) {

 return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
 .setExpiration(new Date(System.currentTimeMillis() + JWT_TOKEN_VALIDITY * 1000))
 .signWith(SignatureAlgorithm.HS512, secret).compact();
 }
 public Boolean validateToken(String token, UserDetails userDetails) {
 final String username = getUsernameFromToken(token);
 return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
 }
} Extending the class for a JWT authentication filter in Spring Security is a common approach to ensure that the filter is only executed once per request. This helps prevent unnecessary duplicate processing and ensures that the filter logic is applied consistently. Create a JwtAuthenticationFilter class which will extend OncePerRequestFilter: OncePerRequestFilter @Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
 private Logger logger = LoggerFactory.getLogger(OncePerRequestFilter.class);
 @Autowired
 private JwtHelper jwtHelper;
 @Autowired
 private UserDetailsService userDetailsService;
 @Override
 protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
 String requestHeader = request.getHeader("Authorization");
 logger.info(" Header : {}", requestHeader);
 String username = null;
 String token = null;
 if (requestHeader != null && requestHeader.startsWith("Bearer")) {
 token = requestHeader.substring(7);
 try {
 username = this.jwtHelper.getUsernameFromToken(token);
 } catch (IllegalArgumentException e) {
 logger.info("Illegal Argument while fetching the username !!");
 e.printStackTrace();
 } catch (ExpiredJwtException e) {
 logger.info("Given jwt token is expired !!");
 e.printStackTrace();
 } catch (MalformedJwtException e) {
 logger.info("Some changed has done in token !! Invalid Token");
 e.printStackTrace();
 } catch (Exception e) {
 e.printStackTrace();
 }
 } else {
 logger.info("Invalid Header Value !! ");
 }
 if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
 UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
 Boolean validateToken = this.jwtHelper.validateToken(token, userDetails);
 if (validateToken) { 
 UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
 authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
 SecurityContextHolder.getContext().setAuthentication(authentication);
 } else {
 logger.info("Validation fails !!");
 }
 }
 filterChain.doFilter(request, response);
 }
} Create a SecurityConfig class as spring security in the configuration file: @Configuration
public class SecurityConfig {
 @Autowired
 private JwtAuthenticationEntryPoint point;
 @Autowired
 private JwtAuthenticationFilter filter;
 @Bean
 public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
 http.csrf(csrf -> csrf.disable())
 .authorizeRequests().
 requestMatchers("/test").authenticated().requestMatchers("/auth/login").permitAll()
 .anyRequest()
 .authenticated()
 .and().exceptionHandling(ex -> ex.authenticationEntryPoint(point))
 .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS));
 http.addFilterBefore(filter, UsernamePasswordAuthenticationFilter.class);
 return http.build();
 }
} Create a login API to accept the username and password: @RestController
@RequestMapping("/auth")
public class AuthController {
 @Autowired
 private UserDetailsService userDetailsService;
 @Autowired
 private AuthenticationManager manager;
 @Autowired
 private JwtHelper helper;
 private Logger logger = LoggerFactory.getLogger(AuthController.class);
 @PostMapping("/login")
 public ResponseEntity<JwtResponse> login(@RequestBody JwtRequest request) {
 this.doAuthenticate(request.getEmail(), request.getPassword());
 UserDetails userDetails = userDetailsService.loadUserByUsername(request.getEmail());
 String token = this.helper.generateToken(userDetails);

 JwtResponse response = JwtResponse.builder()
 .jwtToken(token)
 .username(userDetails.getUsername()).build();
 return new ResponseEntity<>(response, HttpStatus.OK);
 }
 private void doAuthenticate(String email, String password) {
 UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(email, password);
 try {
 manager.authenticate(authentication);
 } catch (BadCredentialsException e) {
 throw new BadCredentialsException(" Invalid Username or Password !!");
 }
 }
 @ExceptionHandler(BadCredentialsException.class)
 public String exceptionHandler() {
 return "Credentials Invalid !!";
 }
} : Creating a JWT request and response involves defining structures for sending and receiving JWTs during the authentication process. Typically, a JWT request is used to send user credentials (e.g., username and password) to the server for authentication, and a JWT response is used to deliver a token upon successful authentication. Create a JWT Request and JWT Response to receive data and send login details @Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@ToString
public class JwtRequest {
 private String email;
 private String password;
} @Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@ToString
public class JwtResponse {
 private String jwtToken;
 private String username;
} Test the API using Postman to generate a JWT token, then use that token as a header in subsequent requests to access the protected API and verify successful authentication. Dive Deeper : youtube.com/watch?v=q2l91Ffc_8U&t=3299s https://springframework.guru/jwt-authentication-in-spring-microservices-jwt-token/ Thank you for reading😊 Also published here.

Mastering JWT Authentication & Authorization in Spring Boot 3.1

Last year, I wrote a on Open Telemetry Tracing to understand more about the subject. I also created a demo around it, which featured the following components: post The Apache APISIX API Gateway A Kotlin/Spring Boot service A Python/Flask service And a Rust/Axum service I've recently improved the demo to deepen my understanding and want to share my learning. Using a regular database In the initial demo, I didn't bother with a regular database. Instead: The Kotlin service used the embedded Java H2 database The service used the embedded SQLite Python The Rust service used hard-coded data in a hash map I replaced all of them with a regular PostgreSQL database, with a dedicated schema for each. The OpenTelemetry agent added a new span when connecting to the database on the JVM and in Python. For the JVM, it's automatic when one uses the Java agent. One needs to install the relevant package in Python - see next section. OpenTelemetry integrations in Python libraries Python requires you to explicitly add the package that instruments a specific library for OpenTelemetry. For example, the demo uses Flask; hence, we should add the Flask integration package. However, it can become a pretty tedious process. Yet, once you've installed , you can "sniff" installed packages and install the relevant integration. opentelemetry-distro pip install opentelemetry-distro

opentelemetry-bootstrap -a install For the demo, it installs the following: opentelemetry_instrumentation-0.41b0.dist-info
opentelemetry_instrumentation_aws_lambda-0.41b0.dist-info
opentelemetry_instrumentation_dbapi-0.41b0.dist-info
opentelemetry_instrumentation_flask-0.41b0.dist-info
opentelemetry_instrumentation_grpc-0.41b0.dist-info
opentelemetry_instrumentation_jinja2-0.41b0.dist-info
opentelemetry_instrumentation_logging-0.41b0.dist-info
opentelemetry_instrumentation_requests-0.41b0.dist-info
opentelemetry_instrumentation_sqlalchemy-0.41b0.dist-info
opentelemetry_instrumentation_sqlite3-0.41b0.dist-info
opentelemetry_instrumentation_urllib-0.41b0.dist-info
opentelemetry_instrumentation_urllib3-0.41b0.dist-info
opentelemetry_instrumentation_wsgi-0.41b0.dist-info The above setup adds a new automated trace for connections. Gunicorn on Flask Every time I started the Flask service, it showed a warning in red that it shouldn't be used in production. While it's unrelated to OpenTelemetry, and though nobody complained, I was not too fond of it. For this reason, I added a "real" HTTP server. I chose for no other reason than because my knowledge of the Python ecosystem is still shallow. Gunicorn The server is a runtime concern. We only need to change the slightly: Dockerfile RUN pip install gunicorn

ENTRYPOINT ["opentelemetry-instrument", "gunicorn", "-b", "0.0.0.0", "-w", "4", "app:app"] The option refers to binding; you can attach to a specific IP. Since I'm running Docker, I don't know the IP, so I bind to any. -b The option specifies the number of workers -w Finally, the argument sets the module and the application, separated by a colon app:app Gunicorn usage doesn't impact OpenTelemetry integrations. Heredocs for the win You may benefit from this if you write a lot of . Dockerfile Every Docker layer has a storage cost. Hence, inside a , one tends to avoid unnecessary layers. For example, the two following snippets yield the same results. Dockerfile RUN pip install pip-tools 
RUN pip-compile
RUN pip install -r requirements.txt
RUN pip install gunicorn
RUN opentelemetry-bootstrap -a install

RUN pip install pip-tools \
 && pip-compile \
 && pip install -r requirements.txt \
 && pip install gunicorn \
 && opentelemetry-bootstrap -a install The first snippet creates five layers, while the second is only one; however, the first is more readable than the second. With , we can access a more readable syntax that creates a single layer: heredocs RUN <<EOF

 pip install pip-tools 
 pip-compile
 pip install -r requirements.txt
 pip install gunicorn
 opentelemetry-bootstrap -a install

EOF Heredocs are a great way to have more readable and more optimized Dockerfiles. Try them! Explicit API call on the JVM In the initial demo, I showed two approaches: The first uses auto-instrumentation, which requires no additional action The second uses manual instrumentation with Spring annotations I wanted to demo an explicit call with the API in the improved version. The use-case is analytics and uses a message queue: I get the trace data from the HTTP call and create a message with such data so the subscriber can use it as a parent. First, we need to add the OpenTelemetry API dependency to the project. We inherit the version from the Spring Boot Starter parent POM: <dependency>
	<groupId>io.opentelemetry</groupId>
	<artifactId>opentelemetry-api</artifactId>
</dependency> At this point, we can access the API. OpenTelemetry offers a static method to get an instance: val otel = GlobalOpenTelemetry.get() At runtime, the agent will work its magic to return the instance. Here's a simplified class diagram focused on tracing: In turn, the flow goes something like this: val otel = GlobalOpenTelemetry.get() //1
val tracer = otel.tracerBuilder("ch.frankel.catalog").build() //2
val span = tracer.spanBuilder("AnalyticsFilter.filter") //3
 .setParent(Context.current()) //4
 .startSpan() //5
// Do something here
span.end() //6 Get the underlying OpenTelemetry Get the tracer builder and "build" the tracer Get the span builder Add the span to the whole chain Start the span End the span; after this step, send the data to the OpenTelemetry endpoint configured. Adding a message queue When I did the talk based on the post, attendees frequently asked whether OpenTelemetry would work with messages such as MQ or Kafka. While I thought it was the case in theory, I wanted to make sure of it: I added a message queue in the demo under the pretense of analytics. The Kotlin service will publish a message to an MQTT topic on each request. A NodeJS service will subscribe to the topic. Attaching OpenTelemetry data to the message So far, OpenTelemetry automatically reads the context to find out the trace ID and the parent span ID. Whatever the approach, auto-instrumentation or manual, annotations-based or explicit, the library takes care of it. I didn't find any existing similar automation for messaging; we need to code our way in. The gist of OpenTelemetry is the HTTP header. We need to read it and send it along with the message. traceparent First, let's add MQTT API to the project. <dependency>
	<groupId>org.eclipse.paho</groupId>
	<artifactId>org.eclipse.paho.mqttv5.client</artifactId>
	<version>1.2.5</version>
</dependency> Interestingly enough, the API doesn't allow access to the directly. However, we can reconstruct it via the class. traceparent SpanContext I'm using MQTT v5 for my message broker. Note that the v5 allows for metadata attached to the message; when using v3, the message itself needs to wrap them. val spanContext = span.spanContext //1
val message = MqttMessage().apply {

 properties = MqttProperties().apply {
 val traceparent = "00-${spanContext.traceId}-${spanContext.spanId}-${spanContext.traceFlags}" //2
 userProperties = listOf(UserProperty("traceparent", traceparent)) //3
 }
 qos = options.qos
 isRetained = options.retained

 val hostAddress = req.remoteAddress().map { it.address.hostAddress }.getOrNull()
 payload = Json.encodeToString(Payload(req.path(), hostAddress)).toByteArray() //4
}
val client = MqttClient(mqtt.serverUri, mqtt.clientId) //5
client.publish(mqtt.options, message) //6 Get the span context Construct the from the span context, according to the W3C Trace Context specification traceparent Set the message metadata Set the message body Create the client Publish the message Getting OpenTelemetry data from the message The subscriber is a new component based on NodeJS. First, we configure the app to use the OpenTelemetry trace exporter: const sdk = new NodeSDK({
 resource: new Resource({[SemanticResourceAttributes.SERVICE_NAME]: 'analytics'}),
 traceExporter: new OTLPTraceExporter({
 url: `${collectorUri}/v1/traces`
 })
})

sdk.start() The next step is to read the metadata, recreate the context from the , and create a span. traceparent client.on('message', (aTopic, payload, packet) => {
 if (aTopic === topic) {

 console.log('Received new message')

 const data = JSON.parse(payload.toString())

 const userProperties = {}
 if (packet.properties['userProperties']) { //1
 const props = packet.properties['userProperties']
 for (const key of Object.keys(props)) {
 userProperties[key] = props[key]
 }
 }

 const activeContext = propagation.extract(context.active(), userProperties) //2
 const tracer = trace.getTracer('analytics')
 const span = tracer.startSpan( //3
 'Read message',
 {attributes: {path: data['path'], clientIp: data['clientIp']}},
 activeContext,
 )
 span.end() //4
 }
}) Read the metadata Recreate the context from the traceparent Create the span End the span For the record, I tried to migrate to TypeScript, but when I did, I didn't receive the message. Help or hints are very welcome! Apache APISIX for messaging Though it's not common knowledge, Apache APISIX can proxy HTTP calls as well as UDP and TCP messages. It only offers a few plugins at the moment, but it will add more in the future. An OpenTelemetry one will surely be part of it. In the meantime, let's prepare for it. The first step is to configure Apache APISIX to allow both HTTP and TCP: apisix:
 proxy_mode: http&stream #1
 stream_proxy:
 tcp:
 - addr: 9100 #2
 tls: false Configure APISIX for both modes Set the TCP port The next step is to configure TCP routing: upstreams:
 - id: 4
 nodes:
 "mosquitto:1883": 1 #1


stream_routes: #2
 - id: 1
 upstream_id: 4
 plugins:
 mqtt-proxy: #3
 protocol_name: MQTT
 protocol_level: 5 #4 Define the MQTT queue as the upstream Define the "streaming" route. APISIX defines everything that's not HTTP as streaming Use the MQTT proxy. Note APISIX offers a Kafka-based one Address the MQTT version. For version above 3, it should be 5 Finally, we can replace the MQTT URLs in the Docker Compose file with APISIX URLs. Conclusion I've described several items I added to improve my OpenTelemetry demo in this post. While most are indeed related to OpenTelemetry, some of them aren't. I may add another component in another different stack, a front-end. The complete source code for this post can be found on . GitHub Also published . here

OpenTelemetry: Improving My Tracing Demo

Rate-limiting, or limiting the speed of request processing, is an important component in modern web applications and APIs. It allows you to manage traffic and protects the system from overloading due to an excessive number of requests. One of the most effective tools for implementing rating in Java applications is the Bucket4j library. Introduction to Bucket4j Bucket4j is a Java language library that provides an API for implementing rate limiting using token buckets. The token bucket method is based on an analogy with a bucket into which tokens drip at a certain rate. Each request to the service extracts a certain number of tokens from this bucket. If there are not enough tokens in the bucket to process the request, the request is postponed or rejected. The Main Features of Bucket4j Bucket4j offers a flexible configuration of rating policies: Multiple restriction strategies: Bucket4j supports various rate limiting strategies, including a limit based on the number of requests per time interval and a bandwidth limit. Flexible configuration: Developers can customize the bucket size, token replenishment rate, and maximum request queue size. Distributed limitation: Bucket4j integrates with distributed repositories such as Hazelcast, Ignite, and Redis, which allows the use of rate-limiting in scalable distributed systems. High performance: The library is optimized to provide high performance and low latency when processing requests. An Example of Using Bucket4j Let's look at a simple example of using Bucket4j to limit the number of requests to the REST API. Suppose we need to limit the number of requests to a certain API to no more than 100 requests per minute. Adding a dependency: First, let's add Bucket4j to the project as a Maven dependency: <dependency>
 <groupId>io.github.bucket4j</groupId>
 <artifactId>bucket4j-core</artifactId>
 <version>последняя версия</version>
</dependency> Creating and configuring a bucket: Bucket bucket = Bucket4j.builder()
 .addLimit(Bandwidth.classic(100, Refill.greedy(100, Duration.ofMinutes(1))))
 .build(); Here, we create a bucket with a limit ofa 100 tokens and a replenishment rate of 100 tokens per minute. Applying the Restriction Before processing each API request, we check whether there are enough tokens in the bucket: if (bucket.tryConsume(1)) {
 // Processing the request
} else {
 // We are sending a response with an error about exceeding the request limit
} Advantages and Limitations of Bucket4j Advantages: Bucket4j allows you to fine-tune the rating policy according to the requirements of the application. Flexibility: Integration with distributed storage makes it an ideal choice for scalable applications. Scalability: Bucket4j integrates seamlessly with various Java frameworks. Easy integration: Limitations: : Bucket4j is designed exclusively for Java applications. Java Dependency In distributed systems, it is necessary to manage the state of buckets to ensure consistency. The need for state management: Conclusion Bucket4j is a powerful tool for implementing rate-limiting in Java applications. Its flexibility, performance, and support for distributed systems make it an ideal choice for modern web applications and APIs that require efficient traffic management and overload protection.

How to Use Bucket4j for Ratelimiters

I never moved away from Docker Desktop. For some time, after you use it to build an image, it prints a message: What's Next?
 View a summary of image vulnerabilities and recommendations → docker scout quickview I decided to give it a try. I'll use the root commit of my . Let's execute the proposed command: OpenTelemetry tracing demo docker scout quickview otel-catalog:1.0 Here's the result: ✓ Image stored for indexing
 ✓ Indexed 272 packages
 Target │ otel-catalog:1.0 │ 0C 2H 15M 23L
 digest │ 7adfce68062e │
 Base image │ eclipse-temurin:21-jre │ 0C 0H 15M 23L
 Refreshed base image │ eclipse-temurin:21-jre │ 0C 0H 15M 23L
 │ │
What's Next?
 View vulnerabilities → docker scout cves otel-catalog:1.0
 View base image update recommendations → docker scout recommendations otel-catalog:1.0
 Include policy results in your quickview by supplying an organization → docker scout quickview otel-catalog:1.0 --org <organization> Docker gives out exciting bits of information: The base image contains 15 middle-severity vulnerabilities and 23 low-severity ones The final image has an additional two high-level severity Ergo, our code introduced them! Following Scout's suggestion, we can drill down the CVEs: docker scout cves otel-catalog:1.0 This is the result: ✓ SBOM of image already cached, 272 packages indexed
 ✗ Detected 18 vulnerable packages with a total of 39 vulnerabilities
## Overview
 │ Analyzed Image
────────────────────┼──────────────────────────────
 Target │ otel-catalog:1.0
 digest │ 7adfce68062e
 platform │ linux/arm64
 vulnerabilities │ 0C 2H 15M 23L
 size │ 160 MB
 packages │ 272
## Packages and Vulnerabilities
 0C 1H 0M 0L org.yaml/snakeyaml 1.33
pkg:maven/org.yaml/snakeyaml@1.33
 ✗ HIGH CVE-2022-1471 [Improper Input Validation]
 https://scout.docker.com/v/CVE-2022-1471
 Affected range : <=1.33
 Fixed version : 2.0
 CVSS Score : 8.3
 CVSS Vector : CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:L
 0C 1H 0M 0L io.netty/netty-handler 4.1.100.Final
pkg:maven/io.netty/netty-handler@4.1.100.Final
 ✗ HIGH CVE-2023-4586 [OWASP Top Ten 2017 Category A9 - Using Components with Known Vulnerabilities]
 https://scout.docker.com/v/CVE-2023-4586
 Affected range : >=4.1.0
 : <5.0.0
 Fixed version : not fixed
 CVSS Score : 7.4
 CVSS Vector : CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N The original output is much longer, but I stopped at the exciting bit: the two high-severity CVEs. First, we see the one coming from Netty still needs to be fixed - tough luck. However, Snake YAML fixed its CVE from version 2.0 onward. I'm not using Snake YAML directly; it's a Spring dependency brought by Spring. Because of this, no guarantee exists that a major version upgrade will be compatible. But we can surely try. Let's bump the dependency to the latest version: <dependency>
 <groupId>org.yaml</groupId>
 <artifactId>snakeyaml</artifactId>
 <version>2.2</version>
</dependency> We can build the image again and . Fortunately, it does. We can execute the process again: check that it still works docker scout quickview otel-catalog:1.0 Lo and behold, the high-severity CVE is no more! ✓ Image stored for indexing
 ✓ Indexed 273 packages
 Target │ local://otel-catalog:1.0-1 │ 0C 1H 15M 23L
 digest │ 9ddc31cdd304 │
 Base image │ eclipse-temurin:21-jre │ 0C 0H 15M 23L Conclusion In this short post, we tried Docker Scout, the Docker image vulnerability detection tool. Thanks to it, we removed one high-level CVE we introduced in the code. To go further: Docker Scout 4 Free, Easy-To-Use Tools For Docker Vulnerability Scanning Also published . here

Docker Images: Kicking the Tires of Docker Scout

Composite keys are when a combination of data is required to define the “key” for your map or cache lookup. An example of this might be where you need to cache values based on a customer name as well as a user’s role. In a case like this, your cache would need to be able to store unique values based on each of these two (or more) criteria. There are a few different ways composite keys can be handled in code. Combine the Criteria Into a String The first answer most jump to is combining the criteria into a string to use as the key. It’s simple and doesn’t take a lot of effort: private String getMapKey(Long userId, String userLocale) {
 return userId + "." userLocale;
} This is a pretty basic way to handle the problem. Using a string key can make debugging and investigations easier, as the cache key is in a human-readable format. But there are a few problems to be aware of with this approach: It requires a new string to be created on every interaction with the map. Though this string allocation is generally small, if the map is accessed frequently, it can lead to a large number of allocations that take time and need to be garbage collected. The size of the string allocation can also be larger depending on how large the components of your key are or how many you have. You need to ensure that the composite key you create can’t get spoofed into another key value: public String getMapKey(Integer groupId, Integer accessType) {
 return groupId.toString() + accessType.toString();
} In the above, if you had groupId = 1 and accessType = 23, that would be the same cache key as groupId = 12 and accessType = 3. By adding a separator character between the strings, you can prevent this kind of overlap. But be careful about optional parts of a key: public String getMapKey(String userProvidedString, String extensionName) {
 return userProvidedString + (extensionName == null ? "" : ("." + extensionName));
} In the above example, extensionName is an optional part of the key. If the extensionName is optional, userProvidedString could include a separator and valid extensionName and get access to cache data it shouldn’t have had access to. When using strings, you’ll want to think about how you are combining your data to avoid any collisions in the keys. Especially around any user-generated input for the key. Use Nested Maps/Caches Another option is to not combine the keys at all, and instead, nest your data structures (Maps of Maps of Maps): Map<Integer, Map<String, String>> groupAndLocaleMap = new HashMap<>();
groupAndLocaleMap.computeIfAbsent(userId, k -> new HashMap()).put(userLocale, mapValue); This has the advantage of not needing to allocate any new memory when interacting with the maps as the passed-in values for the keys are already allocated. And while you will need to do multiple lookups to get to the final value, the maps will be smaller. But the downside to this approach is it gets more complicated the deeper down the nesting goes. Even with only two levels, the map initialization can look confusing. When you start dealing with 3 or more pieces of data, this can lead to making your code very verbose. On top of that, each level requires null checking to avoid null pointers. Some “key parts” also might not work well as a map key. Arrays or collections don’t have default equals methods that compare their contents. So, you would either need to implement them or use another alternative. Using nested maps could also become less space efficient depending on how unique each level of your keys is. Create a Composite Key Object The last option is instead of combining the key values into a string, make a custom object for the key instead: private class MapKey { 
 private final int userId; 
 private final String userLocale; 

 public MapKey(int userId, String userLocale) { 
 this.userId = userId; 
 this.userLocale = userLocale; 
 } 

 @Override 
 public boolean equals(Object o) { 
 if (this == o) return true; 
 if (o == null || getClass() != o.getClass()) return false; 
 MapKey mapKey = (MapKey) o; 
 return userId == mapKey.userId && Objects.equals(userLocale, mapKey.userLocale); 
 } 

 @Override 
 public int hashCode() { 
 return Objects.hash(userId, userLocale); 
 } 
} While every interaction still requires a new memory allocation for a new object. The object key allocation is significantly smaller than the one needed for a composite string. The reason for this is that the parts that make up the key don’t need to get reallocated as strings. Instead, only the wrapping object key requires new memory. A composite key object can also allow for customizations in the key equality and hashcode implementations. Such as ignoring capitalization in a string, or using an array or collection as part of a key. The downside here though is that, again, it requires a lot more code than a composite string does. And it requires ensuring you have valid equals and hashcode contracts in the key class for your map. So which should I choose? Generally speaking, I would suggest using a composite string key. It’s simple and easy to understand, requires the least code, and is easiest to debug later. While it is likely the slowest performing, writing simple, readable code is generally more important than the benefits you would get using one of the other two options. Remember: “Premature optimization is the root of all evil” Donald Knuth If you don’t have evidence or a reason to believe that your map/cache lookup is going to be a performance bottleneck, go with readability. But if you ARE in a scenario where the throughput to your map or cache is very high, then it might be good to switch to one of the other two options. Let’s see how all 3 compare to each other performance-wise, as well as with their memory allocation size. To test the 3 scenarios above, I wrote code that would replicate the same implementation of all 3 scenarios for a composite key. The key itself consists of an integer value, a string value, and a long value. All three implementations used the same test data on each run to build the keys. All runs were executed with 1 million records in the map (Java’s hashmap was used). 3 runs were done building the key with different combinations of key sizes: 100 ints, 100 strings, 100 longs — 1 million unique keys 1 int, 1 string, 1,000,000 longs— 1 million unique keys 1,000,000 ints, 1 string, 1 long — 1 million unique keys First, let’s look at how much space each map takes up in the heap. This is important because it affects how much memory is needed to run your application. There’s one interesting obvious note to make here: in the last scenario (1,000,000 ints), the nested maps size is significantly larger than the others. This is because, in this scenario, the nested maps create 1 first-level map with 1 million entries. Then, for the second and third levels, it creates 1 million maps with only one entry. All those nested maps store extra overhead and are mostly empty. This is obviously an edge case, but I wanted to show it to make a point. When using the nest maps implementation, the uniqueness (and the ordering of that uniqueness) matters a lot. If you reverse the order to 1, 1, 1 million, you actually get the lowest storage requirement. In the other two scenarios, the nested mapping is the most efficient, with the custom key object coming in second, and the string keys coming in last. Next, let’s look at the time it takes to create each of these maps from scratch: Again, we see the nested maps performing the worst in the 1 million-1–1 scenario for memory allocation, but even then, it outperforms the others in CPU time. In the above, we can also see how the String key performs the worst in all cases while using a custom key object is slightly slower and requires more memory allocation than the nested keys. Lastly, let’s look at the highest throughput scenario and how effective it is to read. We ran 1 million read operations (1 for each key created); we did not include any nonexistent keys. This is where we really see how slow the string-based key lookup is. It is by far the slowest and allocates the most memory of any of the 3 options by far. The custom key object performs “close” to the nested maps implementation but is still consistently slower by a small margin. However, in lookup memory allocations, notice how well the nested maps shine. No, that’s not a glitch in the graph; looking up a value in the nested maps requires no extra memory allocations to do the lookup. How is that possible? Well, when combining the composite objects into a string key, you need to allocate memory for a new string object every time: private String lookup(int key1, String key2, long key3) {
 return map.get(key1 + "." + key2 + "." + key3);
} When using a composite key, you still need to allocate memory for a new key object. But because the members of that object are already created and referenced, it still allocates much less than a new string: private String lookup(int key1, String key2, long key3) {
 return map.get(new MapKey(key1, key2, key3));
} But the nested maps implementation requires no new memory allocation on lookup. You are reusing the given parts as keys to each of the nested maps: private String lookup(int key1, String key2, long key3) {
 return map.get(key1).get(key2).get(key3);
} So, based on the above, which is the most performant? It’s easy to see that the nested maps come out on top in almost all scenarios. If you're looking for raw performance in most use cases, it’s likely the best option. Though, you should perform your own testing to confirm your use cases. The key object makes for a very good general-purpose option when nested maps become impractical or impossible to use for your implementation. And the composite string key, though easiest to implement, is almost always going to be the slowest. The last point to consider when looking to implement composite keys is that you can combine the above. For example, you could use nested maps for the first level or two, and then use a composite key object for simplifying the deeper levels. This could still keep your data partitioned for fast lookups while still optimizing storage and lookup performance. And keep your code readable as well. TLDR; Most of the time, just keep it simple. Combine your composite keys into a string key for storage in a map or cache if that is the easiest option and performance is not a major concern. In scenarios where performance is critical, make sure to do your own testing. But using nested maps will be the most performant in most cases. It will also likely have the smallest storage requirements. And composite keys are still a performant alternative when nesting mappings become impractical. Also published here

GRORAPID

grorapid.com

-- employees

Since n.d.

COMPANY RANKING

GRORAPID

EVERGREEN INDEX #4913

Representing this company? Click here to claim and customize this page!

Grorapid WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

GRORAPID

grorapid.com

-- employees

Since n.d.

COMPANY RANKING

GRORAPID

EVERGREEN INDEX #4913

RELATED COMPANIESRANK

STORIES ABOUT GRORAPID

Representing this company? Click here to claim and customize this page!

Grorapid WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!