DEV Community: Malek

Azure Load Testing

Malek — Mon, 18 Dec 2023 21:36:38 +0000

Load testing is the process of Identifying potential bottlenecks, weaknesses, and points of failure of an application. It is a critical part of the software development lifecycle, however, it is a challenging one, as it involves setting up various load conditions to detect failures and issues that may occur at different levels of application usage. It mainly measures the responsiveness, robustness, and performance of the delivered application under normal usage as well as anticipated peak conditions.
In this article, we will learn more details about Load testing within the Azure ecosystem, exploring its concepts and configuration parameters.

Azure Load Testing Service Concepts:

What’s Azure Load Testing:

Azure load testing services enable developers and business to conduct comprehensive load tests by assessing application performance and uncovering the enhancements that could be made to have a more resilient application.

Load testing Key Concepts:

JMeter:

It's an open-source software tool, useful for performing load tests by analyzing the functional behavior of software applications and measuring their performance under various conditions. It offers a high degree of flexibility and customizability, which allows users to fine-tune their load tests to specific requirements and scenarios. JMeter test scripts that describe different load profiles (parameters of the different scenarios) could be imported into Azure load testing service and implemented on the Azure infrastructure.

Test engine instance:

It's an infrastructure computing resource, located in the same location of the azure load testing resource, managed by Microsoft, and runs the Apache JMeter test script, the number of engine instance used for a test are part of the configuration of the test case, as it affects the number of virtual users.
When running the test script, logs generated by the Apache JMeter worker are collected and aggregated by the Azure load testing service to be provided at the end of the test for analysis.

Virtual users:

In Apache JMeter, it's referred to as threads, and a pool of virtual users is referred to as Thread Group. Each virtual user runs a particular test case against the server application independently of the rest of the threads.
However, managing the number of virtual users is not all the time controlled directly, it could also be done through the number of test engine instances. The formula to calculate the total number of virtual users is the following:
Total virtual users = (virtual users in the JMX file) * (number of test engine instances)

Traffic simulation:

Azure load testing helps developers simulate different use cases with varying number of users as well as number of server instances, all while keeping an eye on the system response to the changes of the simulated environment.

Throughput:

Known also as Requests per second (RPS), it's an indicator of the number of requests that the load test service forwards to the server application in a second , it's the number of requests divided by the total execution time in second.
Developers should take into consideration that total execution time includes pauses in between threads if the Jmx test script includes timers.

Performance evaluation:

Azure load testing service measures different types of indicators including response times, throughput, resource utilization and other key performance to ensure the app benchmarks meet the requirements. We can identify two types of metrics:

Server-side metrics: Since the Azure load testing service integrates with Azure Monitor services, we will be able to see logs captured depending on the running service (specific message logs defined in the application, resource consumption, database queries or HTTP requests)

Client-side metrics: Results delivered by the test engine, includes all the test aspects: number of virtual users, number of requests per second, number of succeeded/failed requests, and much more.

Load testing configurations:

Load Profiles:

Defining different scenarios that mimic the intensity of user interactions and the various use cases of the application as well as the frequency of requests. It allows a more comprehensive and realistic test environment.

Network conditions:

Simulating conditions such as latency, bandwidth and protocols help visualize the application performance under specific network constraints.

Test durations:

It represents the time span during which the load test is being conducted, may vary from seconds to days, and it's an important factor of the load testing as it helps developer test the functioning of the application under sustained load for extended periods of time (stress tests) by detecting any degradation or issues that may occur over time.

RampUp time

In the context of load testing, the ramp up times is the duration it takes to embark all the virtual users of the load test gradually, it essentially controls how quickly the users start interacting with the application being tested. It aims to simulate the scenario where the users load increases gradually instead of instantaneously reaching the maximum capacity.
For example, if we have 5 users in the subject test, and we want a new user to join the app each 5 seconds, the ramp up time will be 5*5=25 seconds

Running Load testing in Azure:

For this example, we will need an active azure subscription as well as the right RBAC role that allows creating and managing resources in the subscription (Contributor/Owner)

Creating Azure load Testing resource:

After signing up and filtering the Azure Load testing service from the search field, you can proceed to creation of the service by configuring the subscription, Resource Group, Name, and location. Finally, you may hit the create button to provision your resource.

Create Azure Load Test:

To proceed with the testing, we need to specify a specific URL of the application or service that will be tested, and either upload a JMeter script that contains the configuration and load profiles of the test or configure those details manually in Azure. For this example, we will opt for the latter.

Configuring the tests load profile:

With Azure load testing service configuration, we may define load profile via number of virtual users or Requests Per second (RPS).
Once you have made your choice about the load type, you will need to setup parameters configuration based on your choice, if we proceed with virtual users, we will need to fill in the form with the number of virtual users, test Duration and the Ramp-Up time.
Azure Load testing will automatically create an Apache JMeter script for the load test based on the configuration we just done; you may download the script from the test run on the dashboard.

Note: instead of setting up the test parameters on the dashboard, we can set the configuration in JMeter script file and upload it to the azure load testing service.

Monitoring test results:

Once the test starts, we will get a dashboard that streams the client-side metrics being refreshed every five seconds. Th dashboard offers multiple options and filters to adapt the graphs to display different metrics, aggregate or filter them.

Integrating Azure Load Testing in CI/CD pipelines:

Automated load testing could easily be integrated into the deployment process using Azure Dev-Ops, as it allows to run the load tests after each commit or before each release to make sure that the delivery will be able to handle the use cases covered in our load test.

Before dipping our toes into the configuration of the pipeline, we need to make sure our setup includes the following requirements: An active Azure subscription, an account with the role of application administrator, an Azure DevOps project and organization that is connected to Microsoft Entra ID, and a load testing resource.

Steps:
From the load test resource interface, we click on the Set up CI/CD option and fill in the form details with the organization, projects, repository and branch.

Once the pipeline creation finishes, a notification will show up in your Azure portal with a link to the pipeline, from which you can run the pipeline /modify its steps or triggers.

When you access the pipeline and try to run it, you will need to install Azure load test from visual studio marketplace and assign the pipeline the permission to access the load test resource, once done, the CI/CD pipeline starts running the test.

Finally, you will be able to see the logs of the tests and its results in the pipeline artifact, and you may also download it for further analysis.

Conclusion:

Ensuring the best possible performance in a variety of use cases, load testing is one of the pivotal options that we should consider. Through an extensive presentation of load test concepts, and its integration in Azure as well as including it in the CI/CD pipelines, this article provides developers with the necessary knowledge to run load tests inside an Azure environment. A knowledge that is much needed in today’s digital landscape, where seamless integration of load tests into the projects pipeline is becoming an essential part of the development workflow.

C# Delegates :Types and usage

Malek — Thu, 02 Nov 2023 22:51:20 +0000

If you are in the process of learning or developing in C#, you will certainly stumble upon cases of passing a method as a parameter, all while applying programming concepts such as polling, callbacks, and techniques such as Linq. In this case, you certainly worked with the C# delegates. In this article we'll delve into the details of this concept for a better understanding.

To download the source code for this article, you can visit our GitHub repository.

Delegates Declarartion :
In C#, delegates represent a reference type that points to a method with a specific signature. They can be declared within a class or independently, as shown in the code below:

namespace DelegatesDemo.DelegateAppl {
    public delegate string FirstDelegate (int x);
    public class Sample {
        public delegate void SecondDelegate (char a, char b);
    }
}

Let's instantiate some delegates and use them to refer methods:

namespace DelegatesDemo.DelegateAppl
{
    delegate int ValueSubstitute(int n);
    public static class DelegateDemo
    {
        delegate int ValueUpdate(int n);
        static int Value = 10;
        public static int CurrentValue()
        {
            return Value;
        }
        public static int SumOperation(int p)
        {
            Value += p;
            return Value;
        }
        public static int MultOperation(int q)
        {
            Value *= q;
            return Value;
        }
        public static void RunDelegate()
        {
            ValueUpdate update1 = new ValueUpdate(SumOperation);
            ValueUpdate update2 = new ValueUpdate(MultOperation);


            update1(25);
            Console.WriteLine("Value of Num: {0}", CurrentValue());
            update2(5);
            Console.WriteLine("Value of Num: {0}", CurrentValue());
            Console.ReadKey();
        }
    }
}

We defined two instances of the ValueUpdate delegate. The first delegate is used to get two integers' sum. The second delegate represents the multiplication operation of two integers.
Delegates allow developers to handle methods the same as objects, passing them as parameters, invoking them dynamically, and assigning them to variables. With all these usage scenarios, Microsoft took it a step further providing more specific types of delegates, the Func, Action, and Predicate.
C# Func:

Func represents the delegates that could take one or multiple Input parameters, and return a value. Its declaration depends on the number of parameters the referenced method could take :

Case of no input parameter : Func
Case of one input parameter: Func
Case of two input parameters: Func

The Func delegate in C# could take up to 16 input parameters, besides the TResult which represents the return type of the referenced method, and it does not allow ref and out parameters.

Below, we define and make use of a couple of Funcs:

public static Func<int, int, int> intMultiplyFunc = delegate (int a, int b)
{
    return a * b;
};

int intMultResult = intMultiplyFunc(15, 1);
Console.WriteLine(intMultResult);

This example shows the usage of a Func with an anonymous method, which takes two integers and returns their multiplication result.

The next example shows the usage of a Func with a lambda function that takes two integers and returns their sum:

Func<int, int, int> intSumFunc = (a, b) => a + b;
int intSumResult = intSumFunc(5, 3);
Console.WriteLine(intSumResult);

C# Action:

Similar to the Func concept, Action is a built-in generic delegate that represents one or many methods. It could be defined with an anonymous or lambda function. However, it is limited to methods with no specific return type. It only represents a method with the return type set to void.
We'll define an example of Action that is representing an anonymous method :

Action<string> displayName = delegate (string name)
{
    name = name.ToUpper();
    Console.WriteLine($"Hello, {name}!");
};

displayName("Code Maze");

The displayName delegate in this case takes a string as an argument and makes use of it as per the user requirements: Converting it to uppercase and displaying it. The logic in this case is in the form of an anonymous method, which is a convenient way to write logic that is rather short and not redundant throughout our application.

C# Predicate:

Getting more specific with delegates, Predicates is the delegate representing a method that takes only one input parameter and returns only a boolean type. It is useful when defining a couple of conditions to be checked against the input parameter and returns a boolean value representing whether those criterias were met or not.
Below is an example of a predicate that represents a classic C# method:

static bool IsLowerCase(string str)
{
    return str.Equals(str.ToLower());
}
public static void RunPredicate()
{
    Predicate<string> isUpper = IsLowerCase;


    bool result = isUpper("hello world!!");
    Console.WriteLine(result);
    Console.ReadKey();
}

This Predicate example checks whether a provided string parameter is lowercase or not. As mentioned, it takes only one parameter(string type in this case) and returns a boolean value. It is worth noting that predicates could also be defined using anonymous and Lambda expressions.

Conclusion:

In this article, we delved into one of the most useful C# aspects: delegates. Covering its various types along with examples to help illustrate and clarify the concept. You will need this technique, especially with Linq, implementing design patterns such as Observer, Strategy, and Visitor or writing functional code in C#.

How to approach performance issues II

Malek — Sat, 11 Feb 2023 15:24:06 +0000

Dealing with performance concerns could be an intricated task that transform easily into a story and a sprint of refactoring , testing and code improvements. It's not the best experience you may have as a developer , especially if your team is in a rush and patience is a scarce luxury.
Throughout this article , I will be describing my journey with a similar performance improvement task and how I transformed it into amazing learning experience!

1 - Setting up testing environment
Simulating your production environment for testing your application is a crucial part of this task , as it helps gaining time, having a better visibility on the improvements you are making and excluding solutions that introduce more code complexity than gained milliseconds in terms of latency ! If you need more details about this step, you may refer to the following article.

2 - Identifying bottlenecks in your code
This is a strategic step toward fixing performance issues , because it helps identify improvement plans that will affect most of your endpoints at the same time. to do that , you start by identifying the methods/code logic that are referenced by multiple endpoints , and you focus on them , to check if there is any refactoring or code cleaning to be done.
Identifying the "start with" points is critical to build your strategy of performance enhancement, once you identify them, you proceed with the following steps :

Check if there is any obvious improvements to be implemented
Benchmark those methods to check their latency (using Benchmark.Net Library or the Time attribute of MethodTime.Fody library
Searchand assess improvement options along with running tests to measure the enhancemnts!

Example : While working on a Api improvement , I started by identifying the a method that implements authorization logic , and it was referenced by almost any of the API endpoints. Refactoring and optimizing this methods' logic , helped a lot with improving the overall performance of the API.

3 - Look at the bigger picture
By this I mean , the real big picture , which includes your dev environment , your prod environment , your database management system , your ORMs, and the frameworks you are integrating into your application (if any !)
If a query seems to be slow for no specific reason , even when its logic is straightforward , It's a good idea to try running it on a different environment.
Example : We had a local dev environment composed of visual studio 2022, SQL Server , Redis Microsoft Azure storage Emulator ., and while testing the performance of an endpoint , the SQL profiler shows that a simple query was taking a couple of seconds to execute although it was a simple Select with only one filtering condition! Testing this same query on the Azure db was taking less than 5 ms , which made us question the environment and the area of code we were testing , and it seems that memory issues could cause similar problematic situations , expecially if you are debugging a heavy solution in visual studio and it is running along with an instance of SQL Server on the same machine instance ( a better description of this situation is in this stackoverflow post ). Having such kind of outlook on the situation could help you avoid lots of time investigating issues locally inside your code , while the main concerns are in the environment as whole!

The second path that you should explore in the process of performance checks is the way your are connecting your application to database , certainly there is plenty of choice when it comes to that , so you may be using an ORM ( EF Core, Dapper , Nhibernate ...) , or you may be relying on Simple queries and stored procedures. When working on performance , you should take those choices in consideration , how advanced is your application , and how deep it goes into implementing any of the previous options , comparing those options while taking in account the type / quantity of data you will be handling , considering the choice of adopting one instead of the other , testing some slow methods using a different db connection approach to see if that improves performance and in case of success, should you consider adopting the newly adopted method instead of the previously slow one ? all those are question you should answer and discuss with your team and client, based on the size and the advancement of the application !

Once you are comfortable with the choices you have made for your application ( Frameworks and libraries ) , or even if not , may be you are at the point where you cannot go back and start over with new options, in both cases , you still have alternatives . For example in the case of using EF Core , there is a couple of practices and methods you could adopt for you handle performance issues , you may also want to check the generated SQL of this ORM and find ways to implement it further !

Finally , if you are using frameworks that generate code , or setup the project structure for you ( Example of those are ABP framework ), you should double check the documentation of that framework ,looking for recommendations and best practices in there about performance and considerations. Besides if those frameworks are used to generate a boilerplate code for entities or CRUD operations, It's highly advised to thouroughly review this code and put in place a mechanism or code rules that improve and refactor any of the current/future generated code.

Example : using ABP Framework , could be super helpful as it save you the time to write all the boilerplate code for entities,DTOs and Crud operations , not only that , it does generate the code respecting the architecture you have already setup for your project ( Microservices, DDD ...). All seems awesome until you start the load testing process , and issues start revealing themselves. An example of the issues we had with the generated code was that it makes double db round trip each time we needed to query a list of entities : the first for getting the entities and the second for counting them , which is not a performance friendly approach. For that we had to implement some code refactoring options , and set up some code rule that make sure to fix and chnage these kind of logic everytime we generate new entities using ABP framework.

With the progress those AI tools are making , Github Copilot, OpenAPI , developers may start relying more on their generated code to save time and speed the process. However , the time we gained , we ought to spend some of it on reviewing the generated code instead of taking it as it is , as advanced those tools are, they are still away from perfect !

How to approach performance issues

Malek — Fri, 27 Jan 2023 18:58:44 +0000

Hello there , let me guess : you are suffering tasks/endpoints calls that are taking multiple seconds, but your users are in rush and they couldn't wait that long. so you ought to tackle those latency concerns and you need some recommendations from people who already crossed that path ( and reduced their API calls latency by 80% may be !) . You've come to the right address !

So the process toward an efficient performance improvement plan includes :

1-Identifying the slowest endpoints :

Usually we start raising concerns about performance when the user is struggling to get some data to show up in a timely manner, so obviously , the main trigger to such investigation is the user experience (Let's hope that the user in your case is the QA and not the actual customer ).

And since the slowness reported by the user of those specific endpoints could be not related to you application ( could be related to his internet connection bandwidth or his hardware ...), which brings us to the next step !

2-Make use of monitoring tools :

They are very useful in terms of having a general overview of how is your API behaving through the usual day to day usage of your API. There is multiple great tools on the market for this purpose , but if your API is deployed in an Azure environment , you should consider Azure Insights and Azure monitoring services , the latter was very useful on grouping / Filtering all API calls based on their timing ( which is what we need in this case) , and a bunch of other parameters. It's an awesome service that I consider the source of wisdom , as it helps find out the slowest endpoints along with many other details that are useful for your investigation( duration of the endpoint call , count of calls...).

If Azure is not a viable option for your case , then you should consider other external tools options , I had an experience with Prefix tool , A great monitoring solution , especially for performance related investigations : its options include but not limited to :

Detecting all API calls throughout your navigation journey
Filtering the registered API calls
API call details : Timing, duration , URL, HTTP response type number of queries related to that API call , timing of each query, SQL queries themselves which is super useful in case you are not very familiar with MS SQL profiler ( even more suitable in case of using an ORM such as EF ) The good news is that all of those options are included in the free version of Prefix, its premium version provides much more advanced options.

3-Reproducing the slowness via benchmarking:

When you get into load testing subject , you will get familiar with warmup , outliers, debug/release environments.
Mainly, the point of this step is to reproduce the slowness we are experiencing in the prod environment , but when you try to do that , it is not easily reproducible , so when you hit a specific endpoint, you find its response timing is few milliseconds, but wait a moment, wasn't this endpoint tagged by Azure monitoring or Prefix as slow based on the statistics! yes it is , the one and only , so how could I improve /test an endpoint that is already performant ( well, here comes the famous saying , "it works on my machine" if you know what I mean ;)
Similar to any other bug that you try to fix ( and since you are here , I guess you haven't deal with a few , they are normally your bread and butter ) , so the first step toward finding a solution is to reproduce the problem "On your machine". for that you need to simulate the environment in which this slowness happened and to do that , you will have to :

Prepare a database with similar quantity of data to the one in the prod ( or the environment having the slowness issue), simply because you will not be able to reproduce the issue if you are having 15 items in each of your db tables , but the prod tables , each is having thousands of rows. For this process you may consider preparing a script to load the database with a bulk data, and if you are still in the .Net environment , Bogus framework could be of use in this case
Simulate the application state : means selecting the release option in case of .Net apps , doing an application warmup. Here we go another performance related term !
Warmup is the step of setting the application on the state READY , in order to get accurate measure of the api calls timing. doesn't an API call have the same behavior throughout the whole application lifetime ? the answer is no , at least not exactly , especially when you get into the details .
First time you run the application and start an API call , there is a load of code to be compiled , dependencies to be loaded and injected , caching to be done , Queries and linq expressions to be compiled , monkeypatched methods /classes that are to be defined/loaded on the fly with reflection or Harmony . All those operations do not happen on every request , they happen mainly at the first 10-100 API calls , and because of that , performance measurment taken on the first calls are not as accurate as the ones done later on the process , and their environment/app state is not similar to the environment/app state in which the user encountered slowness. Therefore , you ought to iterate a couple hundreds of calls to the API just before hitting it with calls for performance measurments/ slowness reproduction.
The slowness reported from the monitoring tools is based on thousands of calls done to a specific endpoint , what's showed up as the call duration is the average of the thousands of calls' durations. so you may consider launching thousands of call ( not manually of course !). For this , you will need a tool to launch such kind of scenarios, again , if you are on the .Net environment, the .Net benchmarking tool BenchmarkDotNet could be of interest.

What's the point of this tedious setup ?

Wise question, you here to find some solutions to the performance issues that you are facing , how does this complicated setup , shouldn't be there some possible solution for you to start the improvement plan ?
Yes , I hear you, there is a myriad of solutions that you could implement for your performance improvement plan, and we will get there in the future articles. However, those improvements plans may not be as effective as you expected ,and you will need a solution to find out whether they are effective or not , and if effective , how effective are they , taking into consideration the complexity they introduce into your code base. Besides, setting up a testing environment is crucial for you to verify if there is any real improvement resulting from a specific implemented logic, because , it is not accurate to check/measure improvements just by trying things out with no defined statistics/result, that way , who knows if there was any real improvement, you know the saying " Data is religion, without data you are just another guy with an opinion".

Coming to the end of this article , if you still interested in performance improvement plan , keep an eye on for the next articles ! keep hacking

Mixing Two Blazor component Libraries ( Telerik & Blazorise )

Malek — Thu, 15 Dec 2022 21:43:09 +0000

Lately I have been working on a frontend part of a project that was built in Blazor. The project was mainly built using Abp Suite Framework with Blazor server for frontend.

By default, when you make use of the ABP features of autogenerating CRUD operations endpoints/ interfaces and tests , based on the selected template (In our case , we were using Blazor server with Lepthon theme) , some frontend code will be autogenerated for you for the basic Create/Add/Delete/Update. By default , with blazor frontend themes, the ABP installs/adopts the Blazorise frontend Component library.

It's a useful library with plenty of features (80+ free and open source native Blazor UI controls) that helps with building rich blazor interfaces , and it was a nice default add On to the ABP.

However , since Great ships asks for deep water , same was our ABP application , with the evolving of business requirements , we needed to develop much more complicated forms and interfaces , and yes , it's here where the Blazorise falls short , mainly at Text editor and dynamic tabs components . Then Telerik comes in handy , especially with the rich pack of component and options , including the Text editor and the Dynamic Tab.

We went on with Telerik , all while keeping the Blazorise in place , since we couldn't miss all the ABP auto-generated staff that was so useful. Buying a Telerik license and starting to integarte its different components into our code. It went well at the beginning , except some few warning that we didn't care much about.
Always as the requirements get more complicated, the code base gets to grow and complications arise. and the issues now are much more then just few warnings, as we start encountering weird issues such as :

Components not working as expected ( whether it is Blazorise or Telerik ) : for example input validations, Loader ...
Text editor component of Telerik working fine, but sometimes content gets erased automatically
hundred of warning about Telerik components not being recognised and sometime Blazorise components.

Found markup element with unexpected name 'TelerikCardBody'. If this is intended to be a component, add a @using directive for its namespace.

At first we didn't thought having a mix of those two libraries could be the source of those weird issues , we explored multiple paths including filing support tickets to Telerik, but that didn't resolve the issue. And we noticed that testing those components on a standalone projects worked fine.

Our mistake was that we were nesting components from different sources , which caused those weird issues to happen and make components not functioning clearly as mentioned in the documentation. If you closely into this small portion of sample code , you will see that we were using Blazorise Grid component , inside of it there was TelerikCardBody component , nested in it the Blazorise TextEdit Component. I wouldn't blame the team as when developing this , we were in a rush and had to get the initial version of the interfaces out. but for sure , that wasn't the smartest decision either.

At this point , if you are here to know if different component libraries could be mixed in the same Blazor application , probably you got your answer , and it's yes, you can , but get ready for some unexpected component behavior and irritating issues, so take the Yse with a bit of salt , and avoid this if possible, although I doubt that , especially with highly complicated interfaces as not Library is really perfect.
And if you still hungry for learning , or you are just try to find your way out of a similar situation , don't hesitate to read my next article , in which I will explain how we managed to use both of them with no issues.
With this , we come to the end of this article , I hope you find it useful . Happy Coding <3

confusing issues with EF Core

Malek — Wed, 16 Nov 2022 07:36:28 +0000

Working with ORMs has been a such a life saver for the developers , It reduces their dependency on SQL knowledge and DB administrators , It helps developer be more productive thanks to the easiness of handling DB operations.
It even limits a number of security vulnerabilities that would cause them headaches if logic implemented with SQL.
Also without ORMS, it could be such a painful task to maintain SQL scripts , indexes, stored procedures especially in this era of continuous integration and delivery.
But for which cost do reap all these benefits. In this article , I will go through few of the dark sides of using ORM, my subject for this article is EF Core, which is the ORM I am using in my current project. For that I will go through some of the ambiguous bugs the I faced lately.

Data may have been modified or deleted since entities were loaded

This issue was quiet interesting for me , since we were early on setting up the basic boilerplate code for our modules , and we were building the initial entities , setting up their Crud operations , and while working on the update endpoint of some entities , I encountered this issue . Seemed weird to me at first because am the only one working on this testing data and it's already working only locally, so no way to have the data modified/deleted by another contributor. in the message error on visual studio output , along with the exception there was a link to Microsoft documentation about handling concurrency .
That link wasn't so helpful , because it even made the situation more puzzled. As mentioned in the beginning , we were only setting up the basic CRUD operations ,and we haven't thought nor planned how we are going to deal with concurrency conflicts.
The missed puzzle in this situation is that we were using a Framework name ABP Framework, that would facilitate generating entities , basic logic as well as setting up the general modules structure according to the DDD principles.
What I have missed in this situation was that the entities inherit by default from an AggregateRoot class of the ABP framework , this AggregateRoot class itself implements IHasConcurrencyStamp , which made it obligatory to handle cncurrency stamp conflicts , even if we didn't consider that yet. The issues happens mainly in the following scenario :

We fetch an item from DB with its ID and its specific ConcurrencyStamp ( which was defined by the Framework we adopting for this project , will give it the value XXX)
The Update Endpoint of the API takes as parameters the Item Id (Guid type) as well as the ItemUpdateDto, the latter was also generated by the ABP framework and inherits from the AggregateRootDto and have ConcurrecnyStamp property too.
When the call reaches The API update endpoint with the ID and the EntityUpdateDto , the Update loginc goes as below ;
- Fetch the item from Db using Id provided ( which brings the item with a new specific Concurrency Stamp YYY)
- Map the ItemUpdateDto to the newly fetched item , so now the newly fetched item has the properties updated as well as the ConcurrencyStamp being updated as well , so now its ConcurrencyStamp is XXX
- Save the modified Item to DB

Trying to save the Item to DB using EF Core is no longer possible , because the item when fetched , it had the ConcurrencyStamp of YYY , but now we want to save it with a different one ,wich doesn't make sense for EF Core.

In EF Core , for an entity to be modified and saved it has to keep the same concurrencyStamp throughout the whole process , but in my case , it was changed on the mapping step, which caused this issue What made the situation even more delicate , is the fact that those concurrency Stamps causing this issue weren't intentionally added to to my classes neither they were considered when investigating this issue .

The solution :

The solution that I opted for in this situation is to ignore the concurrency stamp property when mapping the ItemUpdateDto to the newly fetched Item at the step just before saving it with the new modifications.
Following the mapping configuration I put in place dor mapping ItempUpdateDto to a concrete Item:



CreateMap<ItemUpdateDto, Item>()
            .IgnoreAuditedObjectProperties()
            .Ignore(c => c.IsDeleted)
            .Ignore(c => c.DeleterId)
            .Ignore(c => c.DeletionTime)
            .Ignore(c => c.ExtraProperties)
            .Ignore(c => c.ConcurrencyStamp)

Below is the code for the Update endpoint ;



public virtual async Task<ItemDto> UpdateAsync(Guid id, 
        ItemUpdateDto input)
 {
      var item = await _itemRepository.GetAsync(id);
      ObjectMapper.Map(input, item);
      var returnItem = await _itemManager.UpdateAsync(id, item);
      return ObjectMapper.Map<Item, ItemDto>(returnItem);
}

Database operation expected to affect 1 row(s) but actually affected 0 row(s)

With this one ,the exception message also provided a link to official documentation about handling optimistic concurrency exceptions , but I checked concurrency stamps for the update operation and it was matching as required , so why this specific error message. It didn't reveal much of details , and I was stuck for quite some time.
What saved me was changing the way I investigate this kind of issues , so instead of jumping around the LINQ expressions code and the different steps of logic to see what's causing this issue ( which obviously was not working) , I opened SQL profiler to see what are the queries generated by EF Core , and I looked into each of them , they were looking perfect.
I pasted those queries in SQL server and tried to run them , and here the issue appears , which apparently was related to a foreign key constraint that was not valid. I was inserting/Updating a player row into the the players table , in the data I am sending there was a field named TeamId , which was a foreign key referencing the teams table. That foreign key was not valid as it didn't exist in the teams table. But could you have guessed that from the exception message , for me it was almost impossible to spot.

The solution

This way to investigating EF Core issues is the best when the issue happens at the EF call of saving data to DB, and the steps are as mentioned below :

Open SQL profiler from SQL server Management System , from Tools > SQL server Profiler
Spot the queries shown up upon hitting the endpoint causing the issue
Copy these queries and try to execute them on SQL server
If there is issues with the data you are inserting/Updating , SQL server will be more verbose about it , it will point exactly to the constraint , trigger or index causing the issue.

Of course , in this description SQL server is what I was using when investigating this issue , but surely you could try the same process with the DBMS you are using and its own profiler.

If you don't want to use a profiler at all , you could use Stackify Prefix in its free version , it's an awesome tool that displays all the SQL queries created by EF Core , as well as their timing and much more details.

EF Core ; Two foreign key referencing the same table

Implementing some kind of API design in C# code lately has put me in situation where I needed the same table to be referenced two times in one class. For the sake of this article , we'll set the example of class , having two teachers : principle and substitute:
A class should have at least one principle teacher , 0 or 1 substitute teacher , and a teacher may be assigned to multiple classes

To implement this relationship I opted initially for one to many relationship between class and teachers which I realized soon that it is not the right way to implement this, then I kept experimenting with the configuration of the entities in Fluent API , trying to make them created as required in the design , by just Fluent configuration , but in vain.

The solution

What I ended up doing on the entities implementation is the following:



public class Class
     {

        public Guid Id { get; set; }
        public List<Student> Students { get; set; }
        public Guid principalTeacherId { get; set; }
        public Guid substituteTeacherId { get; set; }

        public Teacher principalTeacher { get; set; }
        public Teacher substituteTeacher { get; set; }
      }

public class Teacher
    {
        public Guid Id { get; set; }
        public string Name { get; set; }
        public string Degree { get; set; }
        public int Age  { get; set; }
        public string SubjectName { get; set; }
        public bool IsPrinciple { get; set; }
        public bool IsSubstitute { get; set; }

        //Classes for which the teacher is a substitute
        public List<Class> SubstituteClasses { get; set; }
        //Classes for which the teacher is a principle
        public List<Class> PrincipleClasses { get; set; }
     }


public class Context : DbContext
{
    ...

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Class>()
                    .HasOne(m => m.PrincipalTeacher)
                    .WithMany(t => t.PrincipleClasses)
                    .HasForeignKey(m => m.principalTeacherId )
                    .WillCascadeOnDelete(false);

        modelBuilder.Entity<Class>()
                    .HasRequired(m => m.substituteTeacher)
                    .WithMany(t => t.SubstituteClasses)
                    .HasForeignKey(m => m.substituteTeacherId )
                    .WillCascadeOnDelete(false);
    }
}

All this makes sense especially the way the Class entity is set , but what I missed at the beginning was the fact I should have two Collection of classes in the Teacher entity . Setting that made relationship

Conclusion

Still many more issues that I had to handle to implement all kinds of designs in EF Core Code first that I will be sharing continuously in this blog, so if you find ths subject interesting , keep an eye on the next articles. I hope you are enjoying this learning journey , keep coding !

Error Logging in to Azure Container Registry : Requested access to the resource is denied

Malek — Tue, 30 Jun 2020 01:00:27 +0000

steps of pushing Docker image to Azure Container Registry

Following up the documentation, the first steps that I went through are displayed below :

Sign in to Azure
Create a container registry
Log in to the registry
Push image to the registry
List container images
Run image from the registry
Clean up resources

At the third step, following the instructions of the documentation as shown below, it specifies the rule as following " (Specify only the registry name when logging in with the Azure CLI. Don't include the 'azurecr.io' suffix.) "

That instruction may have worked for some developers, but it cost me half a day logging in and out of azure, restarting docker, and trying all kinds of tips and tricks.

What went wrong ?

"Denied : Requested access to the resource is denied", such an error may delay your production plans if not treated wisely. Trying to test some functionalities on azure container registry (ACR), I created a basic docker image, and followed the official documentation of Microsoft in order to push it into the registry ( already created). Do you think everything worked like charm, Nah! If it did, you won't be reading this article ;) Instead, I got this disturbing error :

How I fixed this ?

The solution was to use the whole registry name including the azurecr.io, contrary to what's specified in the documentation. The commands that worked for me are specified below :

docker login yourregistry.azurecr.io

After running this command, you will need to enter your container registry username and password, you will find them on the Access keys tab under settings section of the container registry home page.
docker image tag imagename:[version] registryname.azurecr.io/imagename:[version]
docker push registryname.azurecr.io/imagename:[version]

After using those commands, I was able to push my images to the Azure container registry, but still don't know why Microsoft does specify that rule in the documentation, and whether it worked for some developers ( without adding the ".azurecr.io" ).

Update

Continuing my learning journey with Azure Container Registry , I found out that the documentation written on 2019 and not updated on the first months of 2020 ( the documentation mentioned above is updated on first months of 2020) , is using the full version of the Azure Registry Container ( RegistryName.azurecr.io ) , so may be this error is related to the version of CLI , am not sure , but I will continue ivestigating this issue whenever I have time. Meanwhile , keep coding and conquer the bugs

More information on the next articles will be provided about the task I was working on when I ran into this issue. If you are using the Azure Container Registry , you may have a comment about the solution or the documentation , please leave it below , and Thanks for reading so far , I hope you learned something new and that this fix works for you.

Error: Resolve-Url-Loader : CSS error

Malek — Sun, 28 Jun 2020 18:08:49 +0000

The famous Resolve Url Loader, a weird issue that I ran into while trying to run a react project for the first time on my newly installed development environment. If you are curious about all these details, you may refer to this article to read about the circumstances in which I ran into this error.

Of course, such errors would push you to start thorough and deep research on the web to know about the why and when and more importantly, the HOW solve it. I already did that, and after trying most of the suggestions, although they worked for some developers, they didn't work in my case. The way I resolved this issue in my project was pretty unique, and that's why I chose to share it in my blog.

I am glad you are here and I hope you find this content useful. Without further ado, let's get to the solution!

since I was trying to run an existing project that I just clone from Github, I ran all the required commands such as :

Yarn install
Yarn upgrade
yarn add react-scripts
Yarn Build
Yarn start

Once I started the project this issue showed up every time, no matter what fixes I tried, so I went back to read the files line by line. Going through the Package.json file, I remarked that some of the packages weren't upgraded, specifically the react-scripts package. It's a set of scripts provided by the create-react-app starter pack, which enables launching React apps without much configuration. This capability comes in the form of multiple features, that include the auto prefixed CSS. And if you read the error details carefully, you will see that the issue is revealed on one of the CSS files. Of course, as part of the error investigation, I changed the CSS files links, I uninstalled, reinstalled, updated the node-sass and the resolve-URL-loader package, but to no avail.
To begin with, let's discover the CSS Autoprefixer , what's it, and what does it? and why is it stopping us from successfully building our newly created/cloned project?

What's CSS AutoPrefixer?

It is a CSS post-processor that parses the compiled CSS files checking it against caniuse service to manage the prefixes related to each vendor.

What's the Autoprefixer role?

It solves the problem we encounter with vendor prefixes that we have to apply to the CSS rules to make some options styles available for a larger variety of users on different browsers.
If that seems like a hard explanation, here it is short and clear: Autoprefixer is taking care of your CSS code, which prevents you from remeberance/add/remove/ check of vendor prefixes.

what's the issue with the Autoprefixer?

when starting a new React project, you will need to install a react-scripts package, which includes the resolve-URL-loader package, the latter role includes management and redirection of the CSS files. connecting the dots, we may understand that the management operation of the CSS files includes the auto prefixing service. Previous versions of the resolve-URL-loader package used to make use of the Rework CSS parser, but as it's not adapted to manage the modern CSS versions, the package of interest adopted the PostCSS parser by default. Long story short, the subject issue was the result of the bad configuration and management of CSS files caused by the Resolve-Url-Loader, itself included in the react-scripts package. Since my development environment was newly installed. I was using the latest version of yarn and upgrading all the packages, which caused the issue.

How I resolved the situation?

Reading the Package.Json file with a fine-tooth comb, I figured out that I was not using the same react-scripts that my team was using on the subject project. Uninstalling the existing react-scripts package and installing the right one served me well.

So here comes the end of my issues with the frontend project, that I built and start successfully. A sigh of satisfaction was about to rise from the bottom of my heart, but it didn't, because the Backend project developed using C#, which was running flawlessly, was launching a new message error, that took almost two days to find a fix, and the solution, was not more common than the one described in this article.

Thank you for reading so far, and if you are willing to learn about the next bug with the .Net project, just click on the next article.

DEV Community: Malek

Azure Load Testing

Azure Load Testing Service Concepts:

What’s Azure Load Testing:

Load testing Key Concepts:

JMeter:

Test engine instance:

Virtual users:

Traffic simulation:

Throughput:

Performance evaluation:

Load testing configurations:

Load Profiles:

Network conditions:

Test durations:

RampUp time

Running Load testing in Azure:

Creating Azure load Testing resource:

Create Azure Load Test:

Configuring the tests load profile:

Monitoring test results:

Integrating Azure Load Testing in CI/CD pipelines:

Conclusion:

C# Delegates :Types and usage

How to approach performance issues II

How to approach performance issues

Mixing Two Blazor component Libraries ( Telerik & Blazorise )

confusing issues with EF Core

Data may have been modified or deleted since entities were loaded

The solution :

Database operation expected to affect 1 row(s) but actually affected 0 row(s)

The solution

EF Core ; Two foreign key referencing the same table

The solution

Conclusion

Error Logging in to Azure Container Registry : Requested access to the resource is denied

steps of pushing Docker image to Azure Container Registry

What went wrong ?

How I fixed this ?

docker login yourregistry.azurecr.io

docker image tag imagename:[version] registryname.azurecr.io/imagename:[version]

docker push registryname.azurecr.io/imagename:[version]

Update

Error: Resolve-Url-Loader : CSS error

What's CSS AutoPrefixer?

What's the Autoprefixer role?

what's the issue with the Autoprefixer?

How I resolved the situation?