Latvian startup Trace.Space has raised €4 million in seed funding from Cherry Ventures, Outlast Fund, Nebular, Fiedler Capital, and Change Ventures to improve

Latvian startup lands €4M seed round to tackle complex manufacturing requirements - ArcticStartup

ATLANTIC BEACH — Atlantic Beach businessman Buddy Cooper, son of one of the town’s principal developers and father of current but soon to-retire 16-year mayor Trace Cooper, recently won a major award for “Mutilator 2,” a sequel to his 1985 cult ...

Buddy Cooper receives award from Joe Bob Briggs Jamboree for ‘Mutilator 2’

The next round of EU sanctions on Moscow could hit more than 5 billion in trade according to Bloomberg sources Read Full Article at RTcom

EU looks to expand sanctions on Russia - Bloomberg

There’s a whole network behind him.’ Halloween McDonald’s toys are back – this is how long you've got to snap one up ‘Three heaped teaspoons of custard easily dissolve into tea without a trace, creating a creamier, moreish liquid that’s ...

People brand man’s tea hack ‘criminal’ — we put it to the test

Some 4.5 billion years or so ago, scientists believe, something big smacked into Earth and knocked it ass over teakettle. The result was a bunch of debris, hurled into space, swirling around until it formed the Moon.

Scientists Detect Traces of an Ancient Alien World Beneath Earth's Mantle

Erick Trace Smith, 33, who has remained in custody since his arrest on Jan. 8, pleaded guilty to aggravated assault on a law enforcement officer and was sentenced to 25 years; to unlawful discharge of a firearm from a vehicle and was sentenced to 20 years ...

Felon who shot at deputy while fleeing in January gets 25 years

KATY, Texas – Deputies are now investigating an apparent murder-suicide after a woman was found dead, believed to have been shot and killed by her husband at a Katy home on Halloween night. According to the Harris County Sheriff’s Office, the deadly encounter took place in the 3150 block of Upland Spring Trace around 11 p.m. Tuesday.

Wife shot, killed by estranged husband before he killed himself in Katy, HCSO says

The latest episode of The Gun Machine, a podcast from WBUR and The Trace, explores how it got this way — and how the NRA, then at the pinnacle of its power, helped bring the industry’s unique legal protections into being. Activists in Kentucky haven ...

Independent Report Concludes Oxford High School Shooting Was Preventable

Parts of Indiana saw snow on Halloween. Indianapolis recorded just a trace of snow, while some spots in northern Indiana got over an inch.

Halloween brings a trace of snow to Indianapolis, measurable snow in northern Indiana

Like any historic site, Fort Ticonderoga has history going back through countless family trees. In October, the fort launched a new project to trace where the roots lead.      The fort launched its new Ticonderoga Soldiers project last month.

Fort Ticonderoga tracing the genealogy of local history

Trace

trace

Java Backend Observability with OpenTelemetry Traces and Minimal Code

ওপেনটেলিমেট্রি ট্রেস এবং ন্যূনতম কোড সহ জাভা ব্যাকএন্ড পর্যবেক্ষণযোগ্যতা

Java-Backend-Beobachtbarkeit mit OpenTelemetry Traces und minimalem Code

Observabilidad del backend de Java con trazas de OpenTelemetry y código mínimo

Observabilité du backend Java avec les traces OpenTelemetry et le code minimal

ओपनटेलीमेट्री ट्रेसेस और न्यूनतम कोड के साथ जावा बैकएंड अवलोकनीयता

OpenTelemetry トレースと最小限のコードによる Java バックエンドの可観測性

OpenTelemetry 추적 및 최소 코드를 사용한 Java 백엔드 관찰성

Observabilidade do backend Java com OpenTelemetry Traces e código mínimo

Наблюдаемость Java Backend с помощью трассировок OpenTelemetry и минимального кода

OpenTelemetri İzleri ve Minimal Kod ile Java Arka Uç Gözlemlenebilirliği

Khả năng quan sát Java Backend với OpenTelemetry Traces và mã tối thiểu

使用 OpenTelemetry Traces 和最少代码实现 Java 后端可观察性

When most people think of NFTs, they think of Bored Ape monkeys and digital artworks, but in reality, it is a universal standard meant for much more. For example, NFTs perfectly represent real-world entities on the blockchain. An NFT can represent the ownership of a real piece of art (such as a painting), allowing it to be traded on the blockchain while the painting remains in a well-protected safe. Similarly, an NFT can represent raw materials, such as the steel needed for car manufacturing, or a container of berries that will eventually be made into smoothies. To these NFTs that represent real entities, we can also assign metadata that provides precise information about the entity associated with the NFT. For instance, in the case of a piece of art, this could include certificates proving authenticity and ownership, or in the case of raw materials, quality statements, and unique attributes like the place of origin. If the metadata is stored on immutable storage, then every change requires updating the metadata reference in the NFT, making the entity's history traceable throughout the blockchain. This history is unchangeable due to the nature of blockchain and immutable storage systems! This brings us to the trace.market project, which we are currently working on in close collaboration with the Swarm Foundation. The system's goal is to allow anyone to freely create NFTs representing physical entities on the Polygon blockchain and to assign metadata to them on Swarm. The blockchain ensures a reliable product history, which can be accessed on Swarm. From the end-users perspective, this looks like scanning a QR code (which contains the NFT ID) on the final product (such as a garment, a box of smoothies, or a car service book) using an app, where they can view the metadata and the complete history. For example, they can verify that the t-shirt was made by recycled textiles, or that the price of refurbished electronics is in balance with its defects. The project uses standard ERC721 NFTs, which are supplemented by two methods for storing and retrieving metadata: function updateMetadata(uint256 tokenId, uint256 swarmHash)
function metadata(uint256 tokenId) The updateMetadata method allows us to modify the metadata assigned to the token. Since the address of content on Swarm is the keccak256 hash of that content, we use uint256 for storage. As the content stored on Swarm is immutable, any change requires us to modify the metadata hash. This ensures that the complete history can be traced on the blockchain. To facilitate traceability, we are also introducing a new event: event metadataUpdated(uint256 indexed _tokenId, uint256 _swarmHash); The event is emitted with every change in metadata, allowing the complete history to be collected based on the tokenId. Since Swarm has its storage incentive system, the storage fee must be covered. This responsibility always falls on the current owner of the NFT. It is in their interest to do so because if the metadata is not accessible, significantly more trust will be needed to sell the product/ NFT. Once the NFT is transferred to a new owner, it then becomes the new owner's responsibility to pay for the storage. During the life cycle of a product, there may be events when the nature of the product changes. For example, locally grown berries are freeze-dried to serve them off-season, or a certified raw material is built into a premium product. Each activity output is detailed in a new NFT, so Industry 5.0’s smart manufacturing can be customized at scale. We refer to these in the system as transformations, and they can occur with the assistance of smart contracts. We distinguish three fundamental types of transformations: 1-1 transformation: In this case, one NFT transforms into another NFT. For example, a container of strawberries becomes a barrel of juice.
1-N transformation (split): In this case, one NFT splits into multiple NFTs. For example, a container of strawberries is divided into two containers, which are then shipped to different countries.
N-1 transformation (merge): In this case, component  NFTs merge into one NFT. This is like when parts are shipped or assembled into a complete car. With these three types, all transformations can be covered. The smart contract executing the transformation locks the source NFT (removes it from circulation) and mints new NFTs in its place. To execute the transformation, the smart contract can verify certain conditions. For example, in the case of a container of berries, a split operation is only permitted if the mass of the resulting new NFTs matches the mass of the source NFT. The mass measurement is performed by reliable external oracles. We store the NFT metadata in the Beeson format developed for Swarm. The advantage of this is that it is verifiable on the blockchain, enabling the transformation smart contract to perform basic Merkle proof checks on the metadata based solely on the Swarm hash (Merkle root). For example, the full price is paid only if the product is manufactured according to a recipe that is confidential but its hash is known. Of course, there are many factors in a transformation that may be difficult or impossible to verify with a smart contract. In such cases, permission from external oracles is required for the transformation (e.g. the location of a vessel). This could be a single oracle or a group of oracles. In the latter case, the transformation can be executed if the majority of the group approves it. Finally, for the sake of example, let's follow this short supply chain: First, the producer picks the bio berries and packs them into a container. Subsequently, an independent validator checks the field and its bio certificate. Photos of the Real-World Asset are uploaded to Swarm, which is linked to the NFT as metadata. Thus, the NFT representing the food is created. Tons of berries go bad or require huge energy during logistics, so a nearby food processor is notified that a batch becomes available. A sales contract is drawn up between the processor and the producer, with the condition that if the location of the container is verified (IoT and logistics oracles, DePIN) on the buyer’s plant, the price will be paid and the buyer will be the owner of the NFT. The processor can merge it with other ingredients, machine capacities, and recipes, so an updated NFT is generated for wholesalers and retailers. On the packaging, a QR code with the NFT ID is placed. When a customer picks up the smoothie in the store, they can scan the QR code to download the metadata stored on Swarm, which can be authenticated based on the history stored on the blockchain. The product's CO2 and water footprint can be estimated most accurately from this metadata, supporting buyers to involve it in buying factors, thereby encouraging manufacturers to minimize CO2 emissions. This is how the trace.market project works in a nutshell. Currently, the project is in testing phase, welcoming API integrations to cope with the urging need for a transparent, Single Source of Truth in products’ sustainability, logistics, resiliency, quality, and custom but structured attributes. I plan to present the system's operation in depth, including the source code level, in a second article once the first version is complete. Kudos to Balint Drahota, the PM of trace.market for helping me clarify the concept, and inspiring me with excellent use cases. When most people think of NFTs, they think of Bored Ape monkeys and digital artworks, but in reality, it is a universal standard meant for much more. For example, NFTs perfectly represent real-world entities on the blockchain. An NFT can represent the ownership of a real piece of art (such as a painting), allowing it to be traded on the blockchain while the painting remains in a well-protected safe. Similarly, an NFT can represent raw materials, such as the steel needed for car manufacturing, or a container of berries that will eventually be made into smoothies. To these NFTs that represent real entities, we can also assign metadata that provides precise information about the entity associated with the NFT. For instance, in the case of a piece of art, this could include certificates proving authenticity and ownership, or in the case of raw materials, quality statements, and unique attributes like the place of origin. If the metadata is stored on immutable storage, then every change requires updating the metadata reference in the NFT, making the entity's history traceable throughout the blockchain. This history is unchangeable due to the nature of blockchain and immutable storage systems! This brings us to the trace.market project, which we are currently working on in close collaboration with the Swarm Foundation . The system's goal is to allow anyone to freely create NFTs representing physical entities on the Polygon blockchain and to assign metadata to them on Swarm. The blockchain ensures a reliable product history, which can be accessed on Swarm. trace.market Swarm Foundation From the end-users perspective, this looks like scanning a QR code (which contains the NFT ID) on the final product (such as a garment, a box of smoothies, or a car service book) using an app, where they can view the metadata and the complete history. For example, they can verify that the t-shirt was made by recycled textiles, or that the price of refurbished electronics is in balance with its defects. The project uses standard ERC721 NFTs, which are supplemented by two methods for storing and retrieving metadata: ERC721 function updateMetadata(uint256 tokenId, uint256 swarmHash)
function metadata(uint256 tokenId) function updateMetadata(uint256 tokenId, uint256 swarmHash)
function metadata(uint256 tokenId) The updateMetadata method allows us to modify the metadata assigned to the token. Since the address of content on Swarm is the keccak256 hash of that content, we use uint256 for storage. As the content stored on Swarm is immutable, any change requires us to modify the metadata hash. This ensures that the complete history can be traced on the blockchain. To facilitate traceability, we are also introducing a new event: updateMetadata event metadataUpdated(uint256 indexed _tokenId, uint256 _swarmHash); event metadataUpdated(uint256 indexed _tokenId, uint256 _swarmHash); The event is emitted with every change in metadata, allowing the complete history to be collected based on the tokenId. Since Swarm has its storage incentive system, the storage fee must be covered. This responsibility always falls on the current owner of the NFT. It is in their interest to do so because if the metadata is not accessible, significantly more trust will be needed to sell the product/ NFT. Once the NFT is transferred to a new owner, it then becomes the new owner's responsibility to pay for the storage. During the life cycle of a product, there may be events when the nature of the product changes. For example, locally grown berries are freeze-dried to serve them off-season, or a certified raw material is built into a premium product. Each activity output is detailed in a new NFT, so Industry 5.0’s smart manufacturing can be customized at scale. We refer to these in the system as transformations, and they can occur with the assistance of smart contracts. We distinguish three fundamental types of transformations: 1-1 transformation: In this case, one NFT transforms into another NFT. For example, a container of strawberries becomes a barrel of juice. 1-N transformation (split): In this case, one NFT splits into multiple NFTs. For example, a container of strawberries is divided into two containers, which are then shipped to different countries. N-1 transformation (merge): In this case, component  NFTs merge into one NFT. This is like when parts are shipped or assembled into a complete car. 1-1 transformation : In this case, one NFT transforms into another NFT. For example, a container of strawberries becomes a barrel of juice. 1-1 transformation 1-N transformation (split) : In this case, one NFT splits into multiple NFTs. For example, a container of strawberries is divided into two containers, which are then shipped to different countries. 1-N transformation (split) N-1 transformation (merge) : In this case, component  NFTs merge into one NFT. This is like when parts are shipped or assembled into a complete car. N-1 transformation (merge) With these three types, all transformations can be covered. The smart contract executing the transformation locks the source NFT (removes it from circulation) and mints new NFTs in its place. To execute the transformation, the smart contract can verify certain conditions. For example, in the case of a container of berries, a split operation is only permitted if the mass of the resulting new NFTs matches the mass of the source NFT. The mass measurement is performed by reliable external oracles. We store the NFT metadata in the Beeson format developed for Swarm. The advantage of this is that it is verifiable on the blockchain, enabling the transformation smart contract to perform basic Merkle proof checks on the metadata based solely on the Swarm hash (Merkle root). For example, the full price is paid only if the product is manufactured according to a recipe that is confidential but its hash is known. Of course, there are many factors in a transformation that may be difficult or impossible to verify with a smart contract. In such cases, permission from external oracles is required for the transformation (e.g. the location of a vessel). This could be a single oracle or a group of oracles. In the latter case, the transformation can be executed if the majority of the group approves it. Finally, for the sake of example, let's follow this short supply chain: First, the producer picks the bio berries and packs them into a container. Subsequently, an independent validator checks the field and its bio certificate. Photos of the Real-World Asset are uploaded to Swarm, which is linked to the NFT as metadata. Thus, the NFT representing the food is created. Tons of berries go bad or require huge energy during logistics, so a nearby food processor is notified that a batch becomes available. A sales contract is drawn up between the processor and the producer, with the condition that if the location of the container is verified (IoT and logistics oracles, DePIN) on the buyer’s plant, the price will be paid and the buyer will be the owner of the NFT. The processor can merge it with other ingredients, machine capacities, and recipes, so an updated NFT is generated for wholesalers and retailers. On the packaging, a QR code with the NFT ID is placed. When a customer picks up the smoothie in the store, they can scan the QR code to download the metadata stored on Swarm, which can be authenticated based on the history stored on the blockchain. The product's CO2 and water footprint can be estimated most accurately from this metadata, supporting buyers to involve it in buying factors, thereby encouraging manufacturers to minimize CO2 emissions. This is how the trace.market project works in a nutshell. Currently, the project is in testing phase, welcoming API integrations to cope with the urging need for a transparent, Single Source of Truth in products’ sustainability, logistics, resiliency, quality, and custom but structured attributes. I plan to present the system's operation in depth, including the source code level, in a second article once the first version is complete. Kudos to Balint Drahota, the PM of trace.market for helping me clarify the concept, and inspiring me with excellent use cases.

Supply Chain Tracking with Ethereum Swarm and NFTs: a brief introduction of trace.market 

If you ask hardcore crypto degens what is the appeal of this new digital asset class, undoubtedly one of the common replies will be pseudonymity. Because transactions are recorded on a public ledger using cryptographic addresses rather than real-world identities, there is an unparalleled degree of privacy when compared to TradFi because transactions are not directly linked to personal information. While it’s true that can offer a higher level of privacy and anonymity, the degree of traceability depends on the specific cryptocurrency and how it is used. With this in mind, it is worth considering just how traceable we are through the money we use - whether real-world, fiat money, or crypto. cryptocurrencies They. See. Everything! It’s no secret that, in traditional finance, there are various mechanisms in place to record and monitor all financial activities, with this kind of traceability being a prominent and built-in feature. The most obvious channel is through bank accounts, with all purchases and transfers of funds documented in bank statements, making a comprehensive overview of a person’s history straightforward for both the account holder and financial institutions to trace and account for various financial activities. Likewise, when we spend via credit and debit cards, a record is generated, and the information is accessible through both the individual's bank statement and the records maintained by merchants and payment processors. There is seemingly no escape from disclosing how we choose to spend to financial institutions, businesses, and even governments. While cash transactions are generally less traceable compared to electronic transactions, they might still be recorded by surveillance cameras in certain locations, and even the act of using an ATM machine to withdraw money from our bank accounts is still always recorded. “As someone who has worked both in the TradFi and , I recognize that while many people feel uncomfortable with the level of privacy they have when it comes to finance, it is also quite necessary for financial institutions to collect certain data points about their clients,” says Yang Lan, Co-Founder of . “My company meets this challenge by allowing users to remain anonymous on the crypto wallet level, with their data stored with us on Swiss soil, and never shared, sold, or abused for any other purpose than for us to meet AML requirements. We bridge the worlds of blockchain and real-world payment data, so we are at a unique intersection here.” DeFi sectors Fiat24 Having made the switch to more online payments, using various digital wallets, for example, actually exposes us to leaving an even more comprehensive electronic trail. All regulated financial institutions, payment service providers, and other relevant entities maintain databases that store transaction details, contributing to this seemingly never-ending traceability process. The interconnected nature of digital financial systems amplifies the visibility of transactions, creating a robust traceability framework. When you consider all of this, you start to wonder - what are banks doing with all of our information and data? While they might tell us that they use it to improve services, manage risks, and meet regulatory requirements, there is always the fear that they just know far too much and even use the knowledge for marketing and advertising purposes. So, is crypto really a much better alternative if you value your privacy? Use Crypto for Privacy? The decentralized and peer-to-peer nature of cryptocurrencies can be said to contribute to increased privacy, as transactions can occur directly between users without the need for intermediaries, hence reducing the number of parties involved in the transaction process. This is in stark contrast with traditional financial services, where transactions pass through multiple entities, each recording the details. Having said this, however, the actual degree of traceability and the level of privacy can vary depending on the specific cryptocurrency used and the user's practices, and achieving complete anonymity in cryptocurrency transactions can be complex. This includes the use of , which often require Know Your Customer (KYC) verification and may link transactions to real-world identities. Decentralized exchanges (DEXs) and off-chain solutions, like the Lightning Network for Bitcoin, provide alternatives that may offer more privacy compared to centralized exchanges, but there are trade-offs for using them. cryptocurrency exchanges As regulation stands to change and evolve further, with developments and legal requirements  influencing the privacy landscape, authorities in some jurisdictions seek to address concerns related to illicit activities. It seems inevitable that even the world of crypto won’t give people the chance to remain anonymous for much longer! Looking ahead The necessity for customer identification across both digital and new technologies within the world of finance makes it apparent that we will always be traceable through the way we handle and spend our money. And while this traceability is crucial for financial oversight, it also prompts a debate about the balance between transparency and individual privacy. Let’s just hope they leave crypto alone for a while longer!

Crypto vs. Cash: How Traceable Is Your Money, Really?

Your team celebrates a success story where a trace identified a pesky latency issue in your application's authentication service. A fix was swiftly implemented, and we all celebrated a quick win in the next team meeting. But the celebrations are short-lived. Just days later, user complaints surged about a related payment gateway timeout. It turns out that the fix we made did improve performance at one point but created a situation in which key information was never cached. Other parts of the react badly to the fix, and we need to revert the whole thing. software While the initial trace provided valuable insights into the authentication service, it didn’t explain why the system was built in this way. Relying solely on a single trace has given us a partial view of a broader problem. This scenario underscores a crucial point: while individual traces are invaluable, their true potential is unlocked only when they are viewed collectively and in context. Let's delve deeper into why a single trace might not be the silver bullet we often hope for and how a more holistic approach to trace analysis can paint a clearer picture of our system's health and the way to combat problems. The Limiting Factor The first problem is the narrow perspective. Imagine debugging a multi-threaded application. If you were to focus only on the behavior of one thread, you might miss how it interacts with others, potentially overlooking deadlocks or race conditions. Java Let's say a trace reveals that a particular method, , is taking longer than expected. By optimizing only this method, you might miss that the real issue is with the synchronized block in another related method, causing thread contention and slowing down the entire system. fetchUserData() Temporal blindness is the second problem. Think of a Java Garbage Collection (GC) log. A single GC event might show a minor pause, but without observing it over time, you won't notice if there's a pattern of increasing pause times indicating a potential memory leak. A trace might show that a Java application's response time spiked at 2 PM. However, without looking at traces over a longer period, you might miss that this spike happens daily, possibly due to a scheduled task or a cron job that's putting undue stress on the system. The last problem is related to that and is the context. Imagine analyzing the performance of a Java method without knowing the volume of data it's processing. A method might seem inefficient, but perhaps it's processing a significantly larger dataset than usual. A single trace might show that a Java method, , took 5 seconds to execute. However, without context, you wouldn't know if it was processing 50 orders or 5,000 orders in that time frame. Another trace might reveal that a related method, , is retrieving an unusually large batch of orders due to a backlog, thus providing context to the initial trace. processOrders() fetchOrdersFromDatabase() Strength in Numbers Think of traces as chapters in a book and metrics as the book's summary. While each chapter (trace) provides detailed insights, the summary (metrics) gives an overarching view. Reading chapters in isolation might lead to missing the plot, but when read in sequence and in tandem with the summary, the story becomes clear. We need this holistic view. If individual traces show that like processTransaction() are occasionally slow, grouped traces might reveal that these slowdowns happen concurrently, pointing to a systemic issue. Metrics, on the other hand, might show a spike in CPU usage during these times, indicating that the system might be CPU-bound during high transaction loads. certain Java methods This helps us distinguish between correlation and causation. Grouped traces might show that every time the method is slow, the method also lags. While this indicates a correlation, metrics might reveal that cache misses (a specific metric) increase during these times, suggesting that database slowdowns might be causing cache update delays, establishing causation. fetchFromDatabase() updateCache() This is especially important in performance tuning. Grouped traces might show that the method's performance has been improving over several releases. Metrics can complement this by showing a decreasing trend in response times and error rates, confirming that recent code optimizations are having a positive impact. handleRequest() I wrote about this extensively in a previous post about the . This motion can be accomplished purely through the use of observability tools such as traces, metrics, and logs. Tong motion needed to isolate an issue Example Observability is somewhat resistant to examples. Everything I try to come up with feels a bit synthetic and unrealistic when I examine it after the fact. Having said that, I looked at my modified version of the venerable Spring Pet Clinic demo using . Running it showed several interesting concepts taken by Digma. digma.ai Probably the most interesting feature is the ability to look at what’s going on in the server at this moment. This is an amazing exploratory tool that provides a holistic view for a moment in time. But the thing I want to focus on is the “Insights” column on the right. Digma tries to combine the separate traces into a coherent narrative. It’s not bad at it, but it’s still a machine. Some of that value should probably still be done manually since it can’t understand the why, only the what. It seems it can detect the venerable Spring seamlessly. N+1 problem But this is only the start. One of my favorite things is the ability to look at tracing data next to a histogram and list of errors in a single view. Is performance impacted because there are errors? How impactful is the performance on the rest of the application? These become questions with easy answers at this point when we see all the different aspects laid together. Magical APIs The N+1 problem I mentioned before is a common bug in . The great Vlad Mihalcea has . The TL;DR is rather simple. We write a simple database query using ORM. But we accidentally split the transaction, causing the data to be fetched N+1 times, where N is the number of records we fetch. Java Persistence API (JPA) an excellent explanation This is painfully easy to do since transactions are so seamless in JPA. This is the biggest problem in “magical” APIs like JPA. These are APIs that do so much that they feel like magic, but under the hood, they still run regular old code. When that code fails, it’s very hard to see what goes on. Observability is one of the best ways to understand why these things fail. In the past, I used to reach to the profiler for such things, which would often entail a lot of work. Getting the right synthetic environment for running a profiling session is often very challenging. Observability lets us do that without the hassle. Final Word Relying on a single individual trace is akin to navigating a vast terrain with just a flashlight. While these traces offer valuable insights, their true potential is only realized when viewed collectively. The limitations of a single trace, such as a narrow perspective, temporal blindness, and lack of context, can often lead developers astray, causing them to miss broader systemic issues. On the other hand, the combined power of grouped traces and metrics offers a panoramic view of system health. Together, they allow for a holistic understanding, precise correlation of issues, performance benchmarking, and enhanced troubleshooting. For this tandem approach ensures a comprehensive and nuanced understanding of applications, optimizing both performance and user experience. In essence, while individual traces are the chapters of our software story, it's only when they're read in sequence and in tandem with metrics that the full narrative comes to life. Java developers, Also published . here

Not A Single Trace: The True Story of Java Performance

In the dynamic landscape of cloud-deployed container workloads, the need for comprehensive performance monitoring to attain granular insights has never been more crucial. Facilitating monitoring capabilities to observe the underlying complex components, and extracting vital real-time insights through metrics and traces, is an absolute requirement for . Kubernetes A cloud-native approach to determine the specifics of each system event, encompassing the capacity to thoroughly monitor and analyze the operational dynamics and efficiency of Kubernetes clusters is an effective way to control the whole network. Kubernetes observability through metrics and traces bridges the gap by enabling you to collect and analyze operational data, guaranteeing the best performance, stability, and scalability. Activation of system-wide metrics and traces promotes with informed troubleshooting, offering an opportunity for performance optimization and increased system reliability. Kubernetes observability Metrics Kubernetes logs a broad spectrum of metrics by default, offering spontaneous information concerning the performance and behavior of cluster components. encompass crucial aspects like networking behavior, pods and node health, resource utilization, and overall application performance. These metrics can act as a gateway to gain a detailed understanding of the overall condition of operational clusters to avoid spot bottlenecks and enable efficient resource allocation. Logs Although there are third-party services to enable Kubernetes metrics, let's see how to facilitate the metrics using the metrics server. The Metrics Server is a Kubernetes component that collects resource consumption measurements from pods and nodes and exposes them for access through Kubernetes API. Metrics Server Deployment kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml Optionally, you can verify the deployment of the metrics server. kubectl get pods -n kube-system | grep metrics-server Traces Interpreting requests end-to-end flow for finding overall latency challenges and anomaly detection of the service is attained by enabling Traces. Distributed tracing presents component interaction insights, assisting in performance bottleneck identification and streamlined . troubleshooting Integrating with a tracing system like Jaeger or Zipkin is often required to enable distributed tracing in Kubernetes. Let's understand how to enable tracing using the commonly used tracing system, Jaeger. apiVersion: v1 kind: Namespace metadata: name: kubernetes-tracing -- apiVersion: apps/v1 kind: DaemonSet metadata: name: 
kubernetes-metrics namespace: kubernetes-tracing spec: selector: matchLabels: app: jaeger component: agent template: 
metadata: labels: app: jaeger component: agent spec: containers:name: kubernetes-metrics-jaeger-agent
image: jaegertracing/jaeger-agent:latest
ports: containerPort: 5775
protocol: UDP
ontainerPort: 5778 protocol: TCP` Agent Deployment kubectl apply -f jaeger-agent.yaml Verify the deployment by accessing the Jaeger UI. kubectl port-forward svc/<jaeger-ui-service-name>-n <namespace> <local-port>:<service-port> The Upside of Implementing Kubernetes Metrics and Traces for Augmented Insights Strategic implementation of advanced monitoring techniques yields an array of advantages as highlighted, concerning the performance and behavior of Kubernetes environments. : Traces enable the detection of resource-hungry components responsible for inefficiencies, while metrics provide admins with insights to allocate resources based on utilization patterns. Efficient Resource Management : Traces unveil room for optimizations by providing profound insights about latency and bottlenecks, while metrics offer resource and application activity monitoring to apply optimizations on-the-fly. Optimized Performance : Traces reveal the auto-scaling effect on the speed and latency of requests, while metrics help decipher how applications behave under heavy load. Scalability Insights : Traces and metrics provide insights into unusual patterns to detect anomalies that may pose security threats leading to breaches, bolstering the total security posture of the Kubernetes environments. Security Boost The Downside of Not Using Kubernetes Metrics and Traces In the absence of Metrics and trace enablement, the state of cluster and application behavior remains a mystery to the teams, forcing them to deal with the problems only after they impact users or interfere with business operations. Also, missing metrics and traces result in a lack of data on resource usage, preventing effective allocation and sparking performance degradation with undetected bottlenecks and difficulty in diagnosis. Best Practices for Enabling Kubernetes Insights Best practice adherence aids security and DevOps teams avoid the most frequently made mistakes, advancing them towards improved Kubernetes observability. Consistent Labeling To ensure efficient aggregation and querying of metrics, uniform, and meaningful labels are significant. Focusing on indicators that have a direct impact, organizations can effectively manage resources and react quickly to deviation from expected behavior. Centralized Alerting Mechanism Sound and robust alerting system implementation to react based on thresholds and anomalies to maintain the health and resistance of production-grade systems. By only focusing on environment-specific alerts, organizations can promote a quick resolution to incidents and enable a secure user experience with increased system reliability. eBPF Probes for Optimal Kernel-Level Observability Organizations can acquire unprecedented insight into the inner workings of the kernel, applications, and network interactions of Kubernetes components by mindfully deploying eBPF probes. eBPF probes facilitate the collection of accurate information without overloading the monitoring infrastructure. Conclusion Despite the reliability promise of cloud-native services, a cautious and robust strategy is a must due to the unknowns of distributed cloud components, especially Kubernetes, that could end up in a chaotic production environment if not managed elegantly. Kubernetes observability is an eccentric technique that makes it possible to rigorously capture, and examine operational data via metrics and traces. By enabling system-wide metrics and traces, Kubernetes observability paves an informed approach to troubleshooting and optimizing the infrastructure, leading to enhanced system reliability.

How Metrics and Traces Power Kubernetes Insights

As developers, it’s important we understand what actually happens under the hood during an Ethereum transaction. Trying to debug, improve, or secure code often has limited visibility into exactly what happens when a smart contract executes. That’s where traces come into play. Ethereum Virtual Machine ( ) EVM In this article, we’ll look at the type of data traces give you, you can execute a trace, and options for tracing — manual, running archive nodes, and using the Infura Trace API. how Traces make an EVM developer’s life a whole lot easier. Let’s start with how they work. Understanding Ethereum Transactions Ethereum transactions involve a lot of information. There’s basic info such as who initiates them, how much gas is used, and when they are called. Plus a set of more complex (and often more important) information such as what is transferred and what smart contract interactions took place. It can be a tough world out there for web3 devs trying to figure it all out! Yes, you can use the transaction receipts to understand the basic info — status code, etc. — but there is still that prevents you from totally understanding what happened and what steps you should take next to fix the issues when they inevitably arrive. a lack of specific, detailed information are the critical piece that gives you missing information — reasons for failure, internal calls, interactions with other contracts, transfers of assets, etc. EVM traces An EVM trace can give you a step-by-step analysis of a transaction, including those details not on-chain. Traces allow you to quickly and clearly see the actions taken by the Ethereum Virtual Machine during a specific transaction. This makes it easier to debug, analyze, and understand dapps/smart contracts and exactly what is going on behind the scenes. You can use the traces to see all those context-rich details you may need as a developer. With trace information, you can: See the details of what’s happening in a transaction Analyze and optimize performance Dig into possible security violations and attack vectors Audit and monitor by tracking the flow of tokens/assets Get historical data for research or analytics tools In short, you need traces when you need a — situations like . granular understanding of what’s happening on Ethereum analysis, debugging Solidity, and improving security So how do you execute a trace? A few common ways to see EVM traces include: You can see a trace API in action and access some of the results at Etherscan.io. You can try to replay the transaction using a full Ethereum node. (Warning: this is complicated, slow, and requires a full node.) You can run a full archive node with traces enabled. (Warning: this is expensive, slow, and requires a full archive node.) You can use a third-party API from your code. Unfortunately, as you can see, a trace can be time and resource intensive. The Inura Trace API is a new option (just released to beta on June 6, 2023) — so let’s look at it in more detail. The Infura Trace API The Infura Trace API is a new set of APIs that gives you a quick and programmatic way to get trace information. From their website: “The is an essential tool for Ethereum developers that provides the ability to gain deeper insights into the execution of smart contracts and transactions on Ethereum. Trace API Developers can retrieve details from transaction data not logged on the blockchain, enabling them to debug, analyze, and perform other tasks and smart contract functions that require a granular understanding of transaction execution on Ethereum.” Using it is easy enough — you just need (and probably already have) an Infura account. If you don’t, sign up for one. Note that the Trace API is only available for paid plans (so you’ll need to create a paid account if you currently have a free one), and it is only available on Ethereum and the testnets, Sepolia and Goerli. Trace API Options Let’s look at the options. There are five types of calls you can make to the Trace API: — Helps you understand what happened during a transaction (gas used, outputs, why it failed, etc). It’s great for optimizing performance. You provide the transaction hash and get back all the trace details. Trace Transaction — Traces all transactions in a given block. Helps you to analyze overall blockchain behavior. Trace Block — Gives you info on a specific call based on a transaction. You provide the and addresses and the . Trace Call is a lot like Trace Transaction — except Trace Call also returns any state diff as well. Trace Call to from block — Just like the above, but traces multiple calls at once. Trace Call Many — You can provide a filter for specific parameters for what traces are returned, such as block #, to address, from address, etc). It can trace from block to block, or from address to address. Allows you to track wallets, contract activity, etc. Trace Filter For more details, . check out the Infura documentation Trace API Example Let’s look at a quick example so you can see what it looks like in action. We’ll use the call to trace . trace_transaction this transaction Request: curl --location 'https://mainnet.infura.io/v3/<INFURA API KEY> \
     --header 'Content-Type: text/plain' \
     --data '{ "id": 1, "method": "trace_transaction", "jsonrpc": "2.0", "params": ["0xeb852958eeb1d026b10c6ad3c995520364b83929e1e0908801194f5b680d54ea"] }' Response: {
  "jsonrpc": "2.0",
  "id": 1,
  "result": [
    {
      "action": {
        "callType": "call",
        "from": "0xeecc9674d3600e3feb1b01b9ff7c72ac2e1c560f",
        "gas": "0x1a0c8",
        "input": "0xe2bbb158000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000037b1d9c38a24b27c",
        "to": "0xfb063b1ae6471e6795d6ad1fc7f47c1cab1f3422",
        "value": "0x0"
      },
      "blockHash": "0x89b3ee89b30133dfd67888bf0baeea58b8a52b1beb983efcc7aa771a3fd489af",
      "blockNumber": 17370663,
      "error": "out of gas",
      "result": null,
      "subtraces": 4,
      "traceAddress": [],
      "transactionHash": "0xeb852958eeb1d026b10c6ad3c995520364b83929e1e0908801194f5b680d54ea",
      "transactionPosition": 110,
      "type": "call"
    },
. . .
} This is a simple example — but you can see in the above that we’ve passed in a transaction hash and gotten back a trace for that transaction, including the reason it failed: More complicated examples can return child traces, filtered results, and more. out of gas. Check out the docs and other tutorials . here Start using Trace APIs Today EVM traces are a critical piece of your life as an Ethereum/EVM developer. They give you the details you need to debug, improve, and secure your code. Hopefully, this article has explained why you need traces, how traces work, and a few ways you can execute a trace to get the info you need. Also published here.

Understanding Ethereum and EVM Traces

From very early times it seems possible to trace two streams of opinion regarding women

Tracing an IP address is an important and useful skill that can help you find the location of a person or website. It can help you discover the identity of an email sender who is trying to conceal their identity online or even track the location of an online business or website. website. Before we get into the steps of IP address tracing, let's explore in-depth about IP addresses. What is an IP Address and How Does it Work? An IP address is a unique label assigned to devices that are connected to a network such as the internet. It identifies each device and allows data to be sent and received between them. An IP address is composed of a series of four numbers, separated by periods, ranging from 0-255. IP stands for Internet Protocol, and is part of the Transmission Control Protocol/Internet Protocol (TCP/IP) suite of protocols. It is the primary protocol for routing data packets in networks and the internet. In the TCP/IP model, each layer of the protocol suite performs specific functions that enable applications to communicate with each other. An IP address is used to identify and locate a device on the network. When a device sends a request to another device, it sends the request to the IP address of the device it is trying to reach. The IP address acts like a street address, and tells the sending device where to send the data. IP addresses can be divided into two categories: public and private. A public IP address is visible to the public, such as a web server or mail server. A private IP address is only visible within a private network, such as a home or office network. IP addresses are assigned to devices using a process called Dynamic Host Configuration Protocol (DHCP). The protocol allows a server to assign IP addresses to devices that are connected to the network. DHCP automatically assigns IP addresses to devices when they are connected to the network. IP addresses also have a limited lifespan. If a device remains inactive for a certain amount of time, the IP address is returned to the pool of available IP addresses. This process is known as IP address expiration. IP addresses play an important role in networks and the internet. They are used to identify and locate devices, and allow data to be sent and received between them. Without IP addresses, the internet would not be able to function. How to Trace an IP Address from Email Yes, you can also trace an IP address from a received email. By tracing an IP address, you can often find out the sender’s location, the ISP they’re using, and even the internet service provider. Here’s a step-by-step guide on how to trace an IP address from Gmail: : Log into your Gmail account. Step 1 : Select the email you want to trace the IP address for. Step 2 : Click the down arrow in the upper right corner of the email and select “Show Original.” Step 3 : This will open a new window with all the email headers. Look for the “Received” headers. Step 4 : The IP address will be listed beside the “Received” header. Step 5 : Copy the IP address and paste it into an IP lookup tool. Step 6 Tracing an IP address from Gmail takes 30 seconds and it can get you the location of the email sender. With this information, you can determine if the sender is legitimate or not. By following these steps, you can easily trace an IP address from an email. This method I have shown above for Gmail. How to Trace an IP Address Using Command Prompt Tracing an IP address with Command Prompt is a simple process that can be done by anyone. Command Prompt is a built-in tool of the windows operating system. It is a great tool for troubleshooting and identifying the location of a computer, server, or website. In this step, we will go through the steps on how to trace an IP address using Command Prompt: : Open the Command Prompt Window. The first step is to open the Command Prompt window. To do this, press the Windows +R keys. Then, type in “cmd” and press enter. This will open the Command Prompt window. Step 1 : Enter the Website. Once the Command Prompt window is open, enter the website URL after “ping” and press enter. The process will take a moment to find out the IP address of the website. Step 2 : Enter the IP Address. Now you will need to enter the IP address you wish to trace. To do this, type in “tracert” followed by the IP address. For example, if you wanted to trace the IP address of www.example.com, you would enter the following command: tracert www.example.com. Step 3 : Trace the IP Address. Once you have entered the command, the Command Prompt window will begin to trace the IP address. It will display a list of IP addresses and the time it took to reach each one. The list will start with the IP address closest to you and end with the IP address of the destination. Step 4 : Identify the Location. To identify the location of the IP address, you can use a tool such as . This tool will allow you to enter the IP address and it will then display the geographic location of the IP address. Step 5 whatismyipaddress.com : Repeat the Process. If you wish to trace multiple IP addresses, you can repeat the same process for each one. Simply enter the command for each IP address and it will display the list of IP addresses and the time it took to reach each one. Step 6 By following these steps, you can easily trace the IP address of your target. This is the most useful IP address trace method for identifying the location of a computer, server, or website.

How to Trace an IP Address for Beginners

Cómo rastrear una dirección IP para principiantes

Comment tracer une adresse IP pour les débutants

शुरुआती लोगों के लिए आईपी एड्रेस कैसे ट्रेस करें

初心者向けのIPアドレスを追跡する方法

Como rastrear um endereço IP para iniciantes

Cách theo dõi địa chỉ IP cho người mới bắt đầu

如何为初学者追踪 IP 地址

Introduction is one of the most powerful tools in , but it has a rather high entry threshold. It allows you to look inside a running application to detect problems. is integrated into . Profiler Android Studio Profiler Android Studio Working with Profiler Let's take as an example of . Full code here: Profiler ProfilerActivity class ProfilerActivity : AppCompatActivity() {
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContent {
           Button(onClick = { countNumber(50) }) {
               Text("Perform methods")
           }
       }
   }

   private fun countNumber(number: Int) {
       if (number == 0) {
           Thread.sleep(2000)
           return
       }
       countNumber(number - 1)
   }
} After launching, you may see the following: The point of this example is to clearly see how works, specifically the stack of methods it calls, how long they take and what effect they have on the processor. To do this, there is a button, when you click it 50 times, the method will be executed. The last method will stop the thread for 2000 ms. There is no business logic in this. This is just to show how the works. So, we should see a pretty deep (50 pieces) and pretty wide (2000ms) stack of methods. Profiler countNumber() Profiler Create a and copy all the code into it. Note that this example uses . So don't forget to include it in the project. Run . ProfilerActivity jetpack compose ProfilerActivity In order to use the Profiler, just go to the tab below: Then click on the plus sign and select the desired device and application process: After selecting the desired application process, it will start monitoring it: The number 6 (see picture above) marks the application process being monitored. The number 1 marks the activation currently in use. In line 2 you can monitor the activity. CPU Line 3 is the usage. RAM Line 4, as you can see, is not active. This was where you could track sending and receiving requests from the network. But it has moved to a separate tab, as you can see from the message marked with the number 7. Network Inspector Line 5 is where you can track your battery usage. In fact, to dive into each of these items, you need to read quite a bit of documentation and articles. In this piece, we will look at the most commonly used and at the same time difficult to enter - CPU monitoring (point 2). Let's click on the CPU line. After clicking we went to the tab monitoring only the processor (point 1, see picture above). You can always go back by clicking on the arrow (point 4). Now let's try to see the stack of methods running in the application. To do this, select (point 2) and select (point 3). After that, the recording starts. Press button in the  application and then press the stop button on the recording (point 5). Java/Kotlin Method Trace Recording Record Perform methods The recording has stopped and the window for analyzing the recorded method stack has opened: If you have done everything correctly, you will see a picture similar to mine. In it you can see: -the pink dot (point 1) - the moment of interaction with the application (pressing the button); -the threads participating in the application (point 2); -the main thread of the application (item 3), where the visual components are rendered; -the executed method stack ( point 4). Click on the arrow next to the stream name and scroll down to reveal the stream and see the details: A column of green and blue lines like this will appear. Notice that you can see the name of the and method: ProfilerActivity.countNumber Thread.sleep If you click on any line, you can find out about the execution of this method, in particular, the total execution time is 2s (2000 ms), which is true: You can also change the scale of the timeline and navigate through it: Mac: Command+Scroll Windows: A, S, D, W The method described above searches the application for problems, usually the longest lines, and then analyzes what caused them. These problems are then eliminated. Finding and eliminating the fault Let's change the application code a little bit: class ProfilerActivity : AppCompatActivity() {

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContent {
           Button(onClick = {
               sleep100()
               sleep100()
               sleep2000()
               sleep100()
           }) {
               Text("Perform methods")
           }
       }
   }

   private fun sleep100() {
       Thread.sleep(100)
   }

   private fun sleep2000() {
       Thread.sleep(2000)
   }
} Suppose we have a long-running application but don't understand what's wrong. Let's run it and record a stack trace, as described earlier: In the picture, you can clearly see that there is a bar that is much longer than the others. It runs for 2000ms and refers to the method. We go to and make sure that the method stops at 2000ms: ProfilerActivity.sleep2000 Android Studio Next, we can take the following actions: -or move execution to the background thread/coroutine; - or start digging further into the code of this method to understand what causes it to take so long to execute and whether it should. By and large, this is the essence of working with . There are more detailed descriptions of methods here, you can write a C++ method stack, and adjust the sampling rate, but the gist is the same. You can read more . Profiler CPU here Conclusion The is a pretty powerful tool that lets you analyze an application at runtime and look for problems in it. You won't need it 95% of the time when you're working on a project. But in the remaining 5% you can't do without it. It's also worth mentioning that is well integrated with , which makes it not only powerful but also incredibly handy compared to other similar tools like . Profiler Profiler Android Studio Perfetto

Recording Stack Trace Methods and Their Analysis With Profiler

Manim is a python library used to create beautiful animation, especially if you want to visualize a mathematical concept. it was invented by 3blue1brown. Unfortunately, the explanation in the documentation of manim is challenging to grasp especially for beginners. Since understanding the basics of any technology is key to building a mental framework and how you can reinvent the wheel, this article will try to explain some simple basic concepts that will explain some code in the documentation. I have a pdf copy where I explain all the classes and methods we will use in detail through this . It simplifies the classes for a beginner to grasp link One of the basics is to understand the manim coordinate system. This is very important when positioning your objects in the scene canvas. In manim, maths object (mobject) is the basic object that we add to our scene canvas and also animate. All mobjects are positioned at the centre of the canvas i.e. (0,0) coordinate by default. every cell represents one Munit (manim unit) When you count the cell in the height, you get 8 Munit and the width will give you around 14.22 Munit. I will be creating a cheat sheet in positioning manim mobjects soon. Let's use the TracedPath class from the manim library to animate a moving dot leaving a trace We will be using google colab to run the code. just run the following code to install the manim library and its dependencies. !sudo apt update
!sudo apt install libcairo2-dev ffmpeg \
texlive texlive-latex-extra texlive-fonts-extra \
texlive-latex-recommended texlive-science \
tipa libpango1.0-dev
!pip install manim
!pip install IPython — upgrade The next step is to all classes, methods and functions from the library. from manim import * This is the complete code and I will be explaining what each line does use the python comment # we use this line to run our code in jupyter or colab notebook specifying our quality of rendering
%%manim -qm -v WARNING  TraceDot

#create a class that will inherit from the Scene class
# we create the canvas for dispaying our mobject

class TraceDot(Scene):

    # This method is where we implement our animation
    def construct(self):
      
      # we instatiate our Dot object and move 2 Munit to the right from origin
      a = Dot(RIGHT * 2)
    
      # we instatiate our trace object from the tracepath class
      b = TracedPath(a.get_center, dissipating_time=0.9, stroke_opacity=[0, 1])
     
      # we add our object to the scene canvas
      self.add(a, b)
      # we animate our dot rotating in a circle counterclock wise and shifting from original position define above two Munit left
      self.play(a.animate(path_arc=8).shift(LEFT * 2), run_time=2)
      
      # we animate our dot rotating in a circle clock wise and shifting two Munit left further
      self.play(a.animate(path_arc=-8 ).shift(LEFT * 2), run_time=2)
      
      # we animate our dot rotating in a circle counterclock wise and two Munit left further
      self.play(a.animate(path_arc=8 ).shift(LEFT * 2), run_time=2)
      
      self.wait() Conclusion Experimenting with python and manim library can be a fun way to learn programming, especially objected-oriented concepts. you will be able to see the result of code through animating mathematical objects(mobjects) and concepts. my next article will be on animating functions and plotting the results. Also Published Here

Stories, News & Mentions about TRACE

Trace’s Stories on HackerNoon

Trace's News & Mentions