Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/DanpowerGruppe/Chia

Chia is a F# library which contains HelperFunctions for reporting, logging and Azure cloud operations.
https://github.com/DanpowerGruppe/Chia

Last synced: 4 months ago
JSON representation

Chia is a F# library which contains HelperFunctions for reporting, logging and Azure cloud operations.

Awesome Lists containing this project

README

        

# Chia - HelperFunctions for reporting

[![Build Status](https://dev.azure.com/DanpowerEnergyData/Chia/_apis/build/status/DanpowerGruppe.Chia?branchName=master)](https://dev.azure.com/DanpowerEnergyData/Chia/_build/latest?definitionId=4&branchName=master)

## Available Packages:

| Library | Version |
| ------------- | ------------- |
| Chia | [![nuget - Chia](https://img.shields.io/nuget/v/Chia.svg?colorB=green)](https://www.nuget.org/packages/Chia/) |
| Chia.Client | [![nuget - ChiaClient](https://img.shields.io/nuget/v/Chia.Client.svg?colorB=green)](https://www.nuget.org/packages/Chia.Client/) |

Chia contains HelperFunctions for reporting. Chia contains some Azure Storage functions, logging features and some excel utils.

## FileWriter

Initialize your FileWriter instant with `initFileWriter`.
If you want to log to ApplicationInsight you have to create a new Application Insight resource in Azure and set your ApplicationInsights key.

```fs
open Chia
open Shared.Logging
open Shared.Config
open InitBuilder
let devStatus = getDevStatusFromEnv /// Get your devStatus from you environment variable. For example pass in an environment variable in Fake --> '-e devStatus=Productive
let fileWriterConfig =
initWriter {
devStatus Development
companyInitials "dp"
projectName "TestChia"
devOption (Azure "aiKey")
```

## Infrastructure

Chia now can help you to set up your Azure infrastructure by using Chia on top of Farmer. You simply create a new FileWriter and then Chia will create a fresh Azure storageaccount in your preferred location. Chia will connect to your storage account and you don't need to add you storage account at all.
Here is an example:

```fs
open Chia
open Infrastructure
open InitWriter
open Shared.Config
open Shared.Logging
open Farmer
let devStatus = Development
let fileWriterConfig =
initWriter {
devStatus Development
companyInitials "dp"
projectName "TestChia"
devOption (Azure "aiKey")
let azAccount = azConnection fileWriterConfig Location.WestEurope
```

## Know issues

Currently Chia doesn't support F# projects which are using TypeProviders. There gonna cause issues with Farmer.

## Log

Once you set configured your initbuilder you can now log to Application Insight or just to a local file

There are three many log functions. `logStarting`, `logFinished` and `logCritical`.

The log function is using categories for clustering events in ApplicationInsights. This will help you to get the most out of the ApplicationInsight dashboard and LogAnalytics.

If you want to log a information that a process is starting you can use `logStarting` like this:

```fs
Log.logStarting("Starting to get Data",LocalServer,Get,AzureTable,fileWriterConfig)
```

If a process finished as expected use `logFinished`:

```fs
Log.logFinished("Finished receiving Data",LocalServer,Get,AzureTable,fileWriterConfig)
```

If a process crashed unexpected use can track the error message with `logCritical`:

```fs
try
let trySomething = unsafe ()
with
| exn ->
let msg = sprintf "Your error message: %s" exn.Message
Log.logCritical (msg,LocalService,LocalServer,Get,AzureTable,exn,fileWriterConfig)
failwith msg
```

The logger uses following clusters.

```fs
Log.logStarting("UsefullMessage",Source,Operation,Destination,filewriterInfo)
```

Here are the implemented descriminated unions:

```fs
type Source =
| LocalService
| LocalServer
| AzureFunction
| AzureInfrastructure
| PiServer
| Client
| SPSCommunication

type Operation =
| Upload
| Download
| Insert
| Query
| Create
| Delete
| Calculation
| Post
| Get
| Restart
| Stop

type Destination =
| AzureTable
| QueueTable
| BlobTable
| SqlTable
| LocalStorage
| EventHub
```

## CreateTable

Helper to create a Azure table:

First connect to your storage account:
```fs
open Chia.CreateTable
let connected =
let connection = AzureConnection StorageAccount.storageConnString
connection.Connect()
```
Now you can create your Azure table like this:

```fs
let azureTable = getTable "TableName" fileWriterConfigAzure connected
```

## CreateBlob

Helper to create a Azure blobs:

First create your blob container:

```fs
open Chia.CreateBlob
let containerInfo = { StorageConnString = StorageConnString = StorageAccount.storageConnString
ContainerName = "ContainerName"}
let myContainer = getContainer containerInfo
```

Now you can get a list of all you blobs in the container like this:

```fs
let blobItems = getBlobs myContainer
```

## GetTableEntry

Helper to query a Azure tables:

With the GetTableEntry module you can easily query Azure Tables.

Get just on single tableValue like this:
```fs
let! value = getValue (request.PartKey, request.RowKey) azureTable
```

Get all values in a table by using a table mapper.
First you have to define you mapper:

```fs
type Mapper = {
PartKey : string
RowKey : Ids.SortableRowKey
}

let mapper (entity : DynamicTableEntity) : Mapper =
{ PartyKey = entity.PartitionKey
RowKey = SortableRowKey entity.RowKey

let! values = getValues mapper azureTable
```

You can also get all values by one rowKey like this:

```fs
let valuesByRowKey = getValuesByRowKey rowKey mapper azureTable
```

If you want to create more complex queries you can just parse in a TableQuery Filter.

First define your filter:

```fs
let filter partKey = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partKey)
let filteredValues partKey = getValuesWithFilter (filter partKey) azureTable
```

## PostToQueue

You can use Chia to sent out a AzureQueue message like this:

```fs
open Chia.PostToQueue
open Chia.CreateTable

let connected =
let connection = AzureConnection StorageAccount.storageConnString
connection.Connect()

[]
let SendMail = "sendmail-queue"

let sendQueue = getQueue connected SendMail fileWriterConfig
```

## RedisCache

Helper to create or directly query a RedisCache:

To create or read a Redis values with a Redis Key you first have to create a Redis cache info:

```fs
let cacheInfo : RedisCache = {
Cache = Redis.cache
Key = key
FileWriterInfo = fileWriterConfig }
```

To deserialze your Redis values to your pass in a System.Text.Json mapper.
You also should pass in a task to receive your data. The function tries to find the cache in Redis. If there is no Redis cache it will create a new cache by executing you task. The following example shows how to receive a Plant array directly out of Redis or creates a new cache if theres no existing cache and returns the Plant array.

```fs
let! plants = tryGetCachedData JsonSerializer.Parse cacheInfo getPlants
```

## EventHub

You can use Chia to sent out a event to Azure Event Hubs like this:

```fs
open Chia.EventHubs

let eventHubClient = getEventHubClient "EventHubSASConnectionString"

type Data = int

let data = 100

do! pushEvent (eventHubClient,data,fileWriterConfigAzure)
do! pushSingleEvent (eventHubClient,data,fileWriterConfigAzure)

```

## ExcelUtils

Mini Helper to start and ExcelApp using the EPPlus package:

Start your excel app like this:

```fs
let excelPackage = startExcelApp ()
```

## Example for a bigger TableMapper

If you want to map your data from Azure to your specific domain types you could do it like this.

```fs
open Chia.CreateTable

type Address =
{ LocationId : Ids.LocationId
PostalCode : string
StreetNr : int option
Additions : string option
Street : string option
Location : string option
Country : string option
FedState : string option }

let mapAddress (entity : DynamicTableEntity) : Address =
{ LocationId = LocationId (entity.PartitionKey |> int64)
PostalCode = entity.RowKey
StreetNr = getOptionalIntProperty "StreetNr" entity
Street = getOptionalStringProperty "Street" entity
Additions = getOptionalStringProperty "Additions" entity
Location = getOptionalStringProperty "Location" entity
Country = getOptionalStringProperty "Country" entity
FedState = getOptionalStringProperty "FedState" entity }
```