PRICING

HELP

BLOG

APPSTORE

COMPANY

LEGAL

LOGIN

AI Assisted Content Management System

Analytics & Lead Generation

Automation Projects

Browser Extension Apps

Dashboard Theme Analysis: LN1

Data Exchange Automation Tools

Getting Started With Building Hybrid Apps

Izyware Hybrid UX Design Guidelines

Onboarding New Organizations Using Izyware

Quick Visualization and Monitoring

Unified Metrics Stream Pipeline

Legacy Features and Backward Compatibility

How does the legacy frame architecture work

Izyware Legacy UI Circus Engine

Case Studies and Knowledge Center

Angular and React Embedding Guide

Build and deploy a content distribution app in less than five minutes: Part II

Comparison of CSS Preprocessors SASS vs LESS vs STYLUS

Comparison of node.js test frameworks and utilities: lab, chai, sinon

Manage and automate your day to day business tools using IzyCloud Tasks: Part I

MySql Performance Optimization

Onboarding Tutorial: Creating & publishing an app

Rebranding and Customizing Websites

Using IzyCloud on Android: IzyCloud Query App

Technical Resources

.NET SDKCore IzyWare

av-stream README

ElasticSearch IzyWare Data Console Feature

End To End Testing

End To End Testing, Part II

frames and nav (ui/w/shell/navmulti) README

izy-circus README

izy-idman-tools README

izy-pop3 README

izy-proxy README

izy-sync README

IzyIDE README

izymodtask readme

IzyShell readme

ReKey Feature Package README for IzyWare SQL Console

Single Sign-On (SSO) README

Tasks Migration : V5 guidelines

Users & Groups README

V5 Migration : apps/pulse guidelines README

Container Orchestration

Izy Kubernetes Internal Networking Troubleshooting

Application Hosting

Content Publisher

Domain Registration

Email Hosting

Izyware Browser Extension

Izyware Deployment Engine

Izyware Session Management

Messaging System APIs and functionality

Single SignOn

Integration APIs

iOS SDK

Azure and .NET

izy-devops

<< Quick Visualization and Monitoring

Legacy Features and Backward Compatibility >>

Unified Metrics Stream Pipeline

Handle the ingestion, processing, and analysis of metrics data from various sources in a unified and efficient manner. Support transport-agnostic and custom data protocols.

+----------------------+

| Unified Metrics |

| Stream |

| Pipeline |

+----------+-----------+

|

v

+-------------------------+------------------------+

| |

v v

+-------------+ +------------------+

| Data | | Data |

| Sources | | Processing |

+------+------+ +------------------+

| |

v v

+------+-------+ +------+-------+

| Data | | Real-time |

| Ingestion | | Analytics |

| Systems | | Engine |

+--------------+ +---------------+

| |

v v

+------+-------+ +------+-------+

| Data | | Data |

| Storage <--------------------------------+ Delivery |

| Systems | | Systems |

+--------------+ +---------------+

• Data Ingestion: Structure event stream data as JSON as much as possible.Structuring data as JSON (JavaScript Object Notation) offers flexibility, readability, and ease of parsing, making it a popular choice for data interchange in various applications. This will allow you to unify all facets of processing log data: collecting, filtering, buffering, and outputting logs across multiple sources and destinations.

• Data Processing: Use stream processing frameworks like Apache Flink, Apache Spark Streaming, or Apache Samza to process events as they arrive. Apply filtering, normalization, aggregation, and enrichment operations to the event stream to extract relevant information.

• Data Storage: Choose appropriate storage solutions to store both raw and processed event data. Use a distributed storage system like Apache Hadoop HDFS, Amazon S3, or Google Cloud Storage for long-term storage of raw event data.

• Real-time Analytics: Implement real-time analytics capabilities to derive insights from streaming event data. Use tools like Apache Druid, Apache Kafka Streams, or Spark Structured Streaming to perform real-time analytics and generate actionable insights. Monitor key metrics, detect anomalies, and trigger alerts based on predefined thresholds or machine learning models. Perform complex analytics tasks such as machine learning model training, cohort analysis, and predictive modeling on historical event data.
• Visualization and Reporting: Build dashboards and reporting tools to visualize and communicate insights derived from event data. See the article titled: "Quick Visualization and Monitoring".
• Monitoring and Management: Implement monitoring and management tools to ensure the reliability, availability, and performance. Use monitoring solutions like Prometheus, Grafana, or Datadog to track system health, resource utilization, and data processing latency. Set up automated alerts and notifications to proactively detect and respond to issues in the event pipeline.

Design Best Practices

When designing a system that needs to support transport-agnostic and custom data protocols, you want to ensure flexibility and interoperability. Here are some considerations and best practices:

• Use a Standard Serialization Format: Choose a standard serialization format like JSON, XML, or Protocol Buffers for encoding your data. This ensures that the data can be easily decoded and understood by systems using different programming languages and platforms.
• Custom Data Protocols: If necessary, design a custom data protocol that meets your specific requirements. Clearly define the format, structure, and rules for encoding and decoding data within this protocol. Document the custom protocol thoroughly so that any system interacting with it can understand how to interpret the data.
• Support Multiple Transport Protocols: Design your system to support multiple transport protocols such as HTTP, MQTT, AMQP, or WebSocket. This provides flexibility for different use cases and integration scenarios.
• Abstract away the transport layer details from your application logic to make it transport-agnostic. Utilize izy-proxy for this task.
• Define Clear Message Contracts: Clearly define the message contracts exchanged between different components or services. Specify the expected structure, data types, and semantics of the messages.
• Use schema definitions or contracts (e.g., OpenAPI for REST, Protocol Buffers schema) to ensure consistency.
• Versioning: Consider incorporating versioning mechanisms into your data protocols. This allows for backward and forward compatibility as your system evolves over time. Include version information in your messages and provide mechanisms for gracefully handling different versions of the protocol.
• Metadata and Headers: Include metadata and headers in your messages to convey additional information. This can be useful for routing, tracing, and other cross-cutting concerns. Standardize the way metadata is included in your messages to enhance consistency.
• Testing and Validation: Implement thorough testing for your transport-agnostic and custom data protocols. Test different scenarios, edge cases, and interoperability with systems using different technologies.

Monitoring Metrics Field Schema

The default izy-proxy monitoring sub system provides the following metrics field schema:

Metric

┌────┴────┐

service ':' Context (Package '?' Query) Event '

' Action

┌┴┐ ┌┴┐

App Container Identification

A "nanoservice" is a term used to describe a very small, lightweight service or microservice. It refers to a service-oriented architecture (SOA) approach where services are broken down into extremely small and focused components. Nanoservices aim to be even smaller in scope and footprint than traditional microservices. They typically perform a very specific task or function, often requiring minimal resources to operate. Nanoservices are designed to be highly modular, easily deployable, and independently scalable. The concept of nanoservices emphasizes granularity and simplicity in service design. By breaking down functionality into smaller units, nanoservices can offer benefits such as improved agility, easier maintenance, and better scalability. However, managing a large number of nanoservices can also introduce complexity in terms of deployment, monitoring, and coordination.