Elixir Monitoring Tools: Observer, New Relic, Telemetry and more

Presented by: Vince Foley

https://elixirforum.com/t/2019-02-20-pdx-elixir-group-elixir-monitoring-tools-observer-new-relic-telemetry-more-portland-oregon-usa/19555

Last week I invented a simple plain-text blogging format called Arcdown (.ad) to assist in publishing rich-featured blog posts in a simple plain-text format. It currently supports these attributes:

• title
• slug
• author/email
• topics/sub-topics
• tags
• article summary/content

It’s compatible with Markdown and presumes you’ll parse the article content with a library like Earmark. I’ve written a relatively robust Arcdown parser and published it to hex as version 0.1.1:

• source: https://github.com/functionhaus/arcdown
• hex package: https://hex.pm/packages/arcdown
• docs: https://hexdocs.pm/arcdown/0.1.1/readme.html

This will be developed into the backend of a plain-text blogging engine called Archivist, somewhat like Nabo but tailored for a more robust featureset. Any thoughts, PRs, or feedback are welcome :)

~Mike

Utah Elixir meetup recording on January 17, 2019: Denver Smith is talking about Mox, an Elixir library for defining concurrent mocks.

https://www.youtube.com/watch?v=HZCntOz6UNE

In this episode of ElixirMix, the panel talks with Anders Smedegaard Pedersen about overcoming the fear of “doing it wrong” and getting started. We talked about Nerves project structure and organization, community standards, contexts, domains, Poncho projects with Nerves and much more!

Podcast Episode

Jose dropped a gem in a recent discussion on elixir-lang-core that for me was totally non-obvious, so I decided to write about it:

https://medium.com/@derek.kraan2/avoid-these-otp-supervision-performance-pitfalls-c3fe64e70f9e

The library works like magic, while the illustrations and annotations I use to explore it will make you cringe!

https://medium.com/@TehBrofessor/whats-going-on-in-libcluster-76f239f00d57

System rewrites are hard. Mitigate risks by planning carefully and doing it incrementally.

https://dev.to/jdcosta/from-rails-to-elixir-safe-rewrites-with-noop-deployments-40cb

Create a High-Availability Kubernetes Cluster on AWS with Kops

This week I’ve published an article mainly focused on DevOps. I show how to create a High-Availability Kubernetes cluster on AWS with Kops and deploy a Phoenix Chat application.

I explain the basics to have our own HA Kubernetes cluster on the cloud, so we can later (in further articles) experiment and discuss on the deployment of Distributed Elixir applications.

I’ve released the first version of CredoPlus. It’s a place for cool features not in Credo - but that you want anyway.

This release adds:

• the report_card command (with HTML output!)
• a check for code coverage

https://hex.pm/packages/credo_plus

My latest post about looping in #Elixir through recursion. I rebuilt a few Enum functions as a learning exercise. It was super interesting seeing pattern matching, function clauses, and the cons operator all work together.

https://davidtang.io/2019/01/13/learning-how-to-loop-in-elixir-through-recursion.html

Use IO.write/2 to craft cool CLI output

https://dennisbeatty.com/2019/01/09/cool-clis-in-elixir-with-io-write-2.html

See how to use Telemetry to hook into your app and record Prometheus metrics. This is a continuation of the previous post on instrumenting your app for Prometheus.

https://blog.smartlogic.io/instrumenting-with-telemetry/

I created a dynamic message board using Nerves and Uderzo.

https://nerves.build/posts/uderzo_msg_board

At Badi, we open sourced a few weeks ago Bolt Routing Driver, the Bolt+Routing Neo4j driver that supports clustering for Elixir using bolt_sips.

It means that you can send a read query to the driver and using one of the load balancing strategies will forward it to a chosen core.

# We need to specify when we are sending a write query that will require to be sent to the leader
iex> Bolt.RoutingDriver.write_query("CREATE (n:Person { name: 'Adrian' })")
[debug] [Bolt.RoutingDriver] localhost:7687 query...
{:ok,
 %{
   stats: %{"labels-added" => 1, "nodes-created" => 1, "properties-set" => 1},
   type: "w"
 }}

# Then we can send read queries, that will be executed in a different follower each time
iex> Bolt.RoutingDriver.read_query("MATCH (n:Person {name: 'Adrian'}) RETURN n")
[debug] [Bolt.RoutingDriver] localhost:7688 query...
{:ok,
 [
   %{
     "n" => %Bolt.Sips.Types.Node{
       id: 0,
       labels: ["Person"],
       properties: %{"name" => "Adrian"}
     }
   }
 ]}

# Now, it will run in a different follower
iex> Bolt.RoutingDriver.read_query("MATCH (n:Person {name: 'Eduard'}) RETURN n")
[debug] [Bolt.RoutingDriver] localhost:7689 query...
{:ok, []}

Any feedback or suggestion is more than welcome!

Morphix, a small library for working with Tuples and Lists, has a new release this week, adding stringmorphification (converting atom keys to map keys) to the list of available functions. Many thanks for the pull request from github/bryanhuntesl.

https://hex.pm/packages/morphix/0.6.0

It is a well-know topic within the Elixir community: “To mock or not to mock? :)”

Every alchemist probably has his / her own opinion concerning this topic. José Valim and Plataformatec has published the Hex package Mox which complies with his article on mocking in Elixir.

Personally, I’m not convinced in having to change the code “in service of” testing certain modules. Why would one add abstraction to code of which its purpose isn’t supposed to be interchangeable (with mock modules for instance)?

After some Googling, I found Espec of which I thought that that’s a little bit too much. Finally, I found Mock which could have done the job. But there are two downsides:

1. You cannot use async: true
2. Defining the mock functions could have been done in a more readable way

Based on that, I decided to write MecksUnit which solves just that. An example:

defmodule Foo do
  def trim(string) do
    String.trim(string)
  end
end

defmodule MecksUnitTest do
  use ExUnit.Case, async: true
  use MecksUnit.Case

  defmock String do
    def trim("  Paul  "), do: "Engel"
    def trim("  Foo  ", "!"), do: "Bar"
    def trim(_, "!"), do: {:passthrough, ["  Surprise!  !!!!", "!"]}
    def trim(_, _), do: :passthrough
  end

  defmock List do
    def wrap(:foo), do: [1, 2, 3, 4]
  end

  mocked_test "using mocked module functions" do
    task =
      Task.async(fn ->
        assert "Engel" == String.trim("  Paul  ")
        assert "Engel" == Foo.trim("  Paul  ")
        assert "Bar" == String.trim("  Foo  ", "!")
        assert "  Surprise!  " == String.trim("  Paul  ", "!")
        assert "MecksUnit" == String.trim("  MecksUnit  ")
        assert "Paul Engel" == String.trim("  Paul Engel  ", " ")
        assert [1, 2, 3, 4] == List.wrap(:foo)
        assert [] == List.wrap(nil)
        assert [:bar] == List.wrap(:bar)
        assert [:foo, :bar] == List.wrap([:foo, :bar])
      end)

    Task.await(task)
  end

  test "using the original module functions" do
    task =
      Task.async(fn ->
        assert "Paul" == String.trim("  Paul  ")
        assert "Paul" == Foo.trim("  Paul  ")
        assert "  Foo  " == String.trim("  Foo  ", "!")
        assert "  Paul  " == String.trim("  Paul  ", "!")
        assert "MecksUnit" == String.trim("  MecksUnit  ")
        assert "Paul Engel" == String.trim("  Paul Engel  ", " ")
        assert [:foo] == List.wrap(:foo)
        assert [] == List.wrap(nil)
        assert [:bar] == List.wrap(:bar)
        assert [:foo, :bar] == List.wrap([:foo, :bar])
      end)

    Task.await(task)
  end
end

Mocking module functions is pretty straightforward and done as follows:

1. Add use MecksUnit.Case at the beginning of your test file
2. Use defmock as if you would define the original module with defmodule containing mocked functions
3. Use mocked_test as if you would define a normal ExUnit test after having defined all the required mock modules

The defined mock modules only apply to the first mocked_test encountered. So they are isolated (despite of :meck having an unfortunate global effect) as MecksUnit takes care of it. Also, non-matching function heads within the mock module will result in invoking the original module function as well. And last but not least: you can just run the tests asynchronously.

Enjoy using MecksUnit (if you prefer unobtrusive mocking). A Github star is very welcome, haha ;)

In this post, we’re going to look at capturing functions and expressions, which can make Elixir code more concise.

https://davidtang.io/2019/01/10/capturing-functions-and-expressions-in-elixir.html

As well as having Ecto use UUIDs as primary keys it is also possible for Ecto to configure PostgreSQL so that it generate the UUIDs:

http://www.swwritings.com/post/2019-01-11-ecto-and-binary-ids-generated-by-postgresql

New version of ExCampaignMonitor (0.9.0) to start working through the transactional API: https://hexdocs.pm/ex_campaign_monitor/0.9.0/ExCampaignMonitor.html#send_smart_email/2

When you have a service module that does something with a third party using a mock module can prove to be a great tool for testing when you don’t want to depend on that external service. In my post I show you how to do that without dependency injection but rather with elixir’s application configuration.

https://polymorphic.productions/posts/using-configuration-to-swap-modules-for-mocks-in-your-elixir-tests