profile
viewpoint
If you are wondering where the data of this site comes from, please visit https://api.github.com/users/sneako/events. GitMemory does not store any data, but only uses NGINX to cache data for a period of time. The idea behind GitMemory is simply to give users a better reading experience.
nico piderman sneako AppMonet Barcelona, ES Elixir developer

keathley/finch 792

Elixir HTTP Client focused on performance

nothingworksinc/ticketbeast 535

Back to the lesson videos:

bitwalker/exprotobuf 474

Protocol Buffers in Elixir made easy!

AppMonet/open_rtb_ecto 4

OpenRTB 2.5 & 3.0 Ecto Schemas

AppMonet/transparency_and_consent 1

IAB Transparency & Consent Framework v1.1 & v2 Support

sneako/advent_of_code_2019 1

https://adventofcode.com/2019

sneako/absinthe 0

The GraphQL toolkit for Elixir

sneako/alpine-elixir 0

A Dockerfile based on my alpine-erlang image for Elixir applications

pull request commenterlang/otp

inet_res validate reply OTP-17323

This has been running now for a over 4 hours. Traffic has increased to >17k outgoing HTTP requests per second per node. All of my application metrics are consistent across the two version and look good. There have been 0 errors during this time. As far as I am concerned this PR is good :+1:

I will end the test now.

Thanks for the great work!

RaimoNiskanen

comment created time in 3 days

pull request commenterlang/otp

inet_res validate reply OTP-17323

Good morning @RaimoNiskanen !

I have just begun testing this. Currently I have most of my nodes running OTP 24.0.6, and one node running the same OTP version plus this patch.

I slowly ramped up the traffic levels until all nodes were receiving similar amounts of traffic. Each of these nodes is sending out ~11k HTTP requests per second across a dozen or so different hosts.

So far the nodes have been running at this level of traffic for ~45min and I have not seen any errors or strange changes in my application metrics, everything is looking good!

I will leave this node with the patched OTP version running for a few hours and report back.

In the meantime, if you have anything specific you would like me to check, please let me know.

RaimoNiskanen

comment created time in 3 days

create barnchsneako/elixir-jit-docker

branch : pr-5061

created branch time in 3 days

create barnchsneako/otp

branch : OTP-24.0.6-inet_validate

created branch time in 4 days

pull request commenterlang/otp

inet_res validate reply OTP-17323

Hi @RaimoNiskanen, I'm sorry but a few things came up at work that I had to handle first. I am wrapping that up today, and I'll try to get to this next week.

RaimoNiskanen

comment created time in 8 days

CommitCommentEvent
CommitCommentEvent

pull request commenterlang/otp

inet_res validate reply OTP-17323

Sorry @RaimoNiskanen I have had my hands full, but I should be able to try it out sometime next week for you. Really appreciate your work here!

RaimoNiskanen

comment created time in 18 days

fork sneako/sentry-docs

The new place for the sentry documentation (and tools to build it)

https://docs.sentry.io

fork in 25 days

startedcode-lever/asdf-rust

started time in a month

startedwojtekmach/openapi

started time in a month

issue commentkeathley/finch

Support unix sockets

I like @wojtekmach's proposal of using a new :unix_socket option rather than some kind of hybrid scheme. We could add a :unix_socket field to the Request struct and from there it should be quite straightforward.

dallagi

comment created time in a month

startedkeathley/finch

started time in a month

delete branch sneako/telemetry

delete branch : sneako-patch-1

delete time in a month

issue openedphoenixframework/phoenix

Telemetry 1.0 warnings

Since upgrading to Telemetry 1.0, I am now seeing the following warnings emitted:

15:57:30.098 [info]  Function passed as a handler with ID {Phoenix.Logger, [:phoenix, :channel_handled_in]} is local function.
This mean that it is either anonymous function or capture of function without module specified. That may cause performance penalty when calling such handler. For more details see note in `telemetry:attach/4` documentation.

https://hexdocs.pm/telemetry/telemetry.html#attach-4

15:57:30.116 [info]  Function passed as a handler with ID {Phoenix.Logger, [:phoenix, :channel_joined]} is local function.
This mean that it is either anonymous function or capture of function without module specified. That may cause performance penalty when calling such handler. For more details see note in `telemetry:attach/4` documentation.

https://hexdocs.pm/telemetry/telemetry.html#attach-4

15:57:30.116 [info]  Function passed as a handler with ID {Phoenix.Logger, [:phoenix, :endpoint, :start]} is local function.
This mean that it is either anonymous function or capture of function without module specified. That may cause performance penalty when calling such handler. For more details see note in `telemetry:attach/4` documentation.

https://hexdocs.pm/telemetry/telemetry.html#attach-4

15:57:30.116 [info]  Function passed as a handler with ID {Phoenix.Logger, [:phoenix, :endpoint, :stop]} is local function.
This mean that it is either anonymous function or capture of function without module specified. That may cause performance penalty when calling such handler. For more details see note in `telemetry:attach/4` documentation.

https://hexdocs.pm/telemetry/telemetry.html#attach-4

15:57:30.116 [info]  Function passed as a handler with ID {Phoenix.Logger, [:phoenix, :error_rendered]} is local function.
This mean that it is either anonymous function or capture of function without module specified. That may cause performance penalty when calling such handler. For more details see note in `telemetry:attach/4` documentation.

https://hexdocs.pm/telemetry/telemetry.html#attach-4

15:57:30.116 [info]  Function passed as a handler with ID {Phoenix.Logger, [:phoenix, :router_dispatch, :start]} is local function.
This mean that it is either anonymous function or capture of function without module specified. That may cause performance penalty when calling such handler. For more details see note in `telemetry:attach/4` documentation.

https://hexdocs.pm/telemetry/telemetry.html#attach-4

15:57:30.116 [info]  Function passed as a handler with ID {Phoenix.Logger, [:phoenix, :socket_connected]} is local function.
This mean that it is either anonymous function or capture of function without module specified. That may cause performance penalty when calling such handler. For more details see note in `telemetry:attach/4` documentation.

https://hexdocs.pm/telemetry/telemetry.html#attach-4

I believe the solution is to simply change these function captures here: https://github.com/phoenixframework/phoenix/blob/385bdebdcc879dfb06f02faa5bef7d5e0b97761c/lib/phoenix/logger.ex#L125

to:

    handlers = %{
      [:phoenix, :endpoint, :start] => &__MODULE__.phoenix_endpoint_start/4,
      [:phoenix, :endpoint, :stop] => &__MODULE__.phoenix_endpoint_stop/4,
      [:phoenix, :router_dispatch, :start] => &__MODULE__.phoenix_router_dispatch_start/4,
      [:phoenix, :error_rendered] => &__MODULE__.phoenix_error_rendered/4,
      [:phoenix, :socket_connected] => &__MODULE__.phoenix_socket_connected/4,
      [:phoenix, :channel_joined] => &__MODULE__.phoenix_channel_joined/4,
      [:phoenix, :channel_handled_in] => &__MODULE__.phoenix_channel_handled_in/4
    }

Environment

  • Elixir version (elixir -v): 1.12.2
  • Phoenix version (mix deps): 1.5.9
  • Node.js version (node -v): v12.13.0
  • Operating system: macOS

I am happy to open a PR if so.

created time in a month

create barnchsneako/telemetry

branch : sneako-patch-1

created branch time in a month

fork sneako/telemetry

Dynamic dispatching library for metrics and instrumentations.

https://hexdocs.pm/telemetry

fork in a month

issue commentg-andrade/locus

Ability to pass a function as a database source

Wow, that looks like it should definitely cover my use case. Thank you!

sneako

comment created time in 2 months

issue openedg-andrade/locus

Ability to pass a function as a database source url

Hi there!

We are interested in building our own geolocation db and hosting the mmbd file in S3.

We would like to make this S3 object private and our application already has its own AWS credentials, which it can use to access the private S3 object. I realize that I could write some code to use these credentials and download the mmdb to the local filesystem, but this application runs in kubernetes and we would rather not introduce volumes if it is not necessary.

Therefore, I am proposing locus be extended to allow an {M,F,A} tuple to be passed as the db source. The function could return any of the types accepted by locus:start_loader/2.

I would be happy to implement this functionality if you agree that it is probably the best way to handle this kind of scenario.

Thanks for reading!

created time in 2 months

pull request commentkeathley/finch

Support telemetry v1.0

@joshnuss Done!

wingyplus

comment created time in 2 months

created tagkeathley/finch

tagv0.8.1

Elixir HTTP Client focused on performance

created time in 2 months

push eventkeathley/finch

Nico Piderman

commit sha 5334732450a873c1ee969d729a08b7b2c84904e9

bump version

view details

push time in 2 months

startednetdata/netdata

started time in 2 months

startedswoosh/swoosh

started time in 2 months

PullRequestReviewEvent

fork sneako/kubernetes

Production-Grade Container Scheduling and Management

https://kubernetes.io

fork in 2 months

issue commentkeathley/finch

Support custom Mint transports

Custom transports are not officially supported by Mint so I am not sure that we should try to add this feature that depends on a private API, see: https://github.com/elixir-mint/mint/pull/323

dannote

comment created time in 3 months

issue commentkeathley/finch

Error struct

is it possible that in this place

children = [
  {Finch,
   name: MyConfiguredFinch,
   pools: %{
     :default => [size: 10],
     "https://hex.pm" => [size: 32, count: 8]
   }}
]

we can also define the return behaviour of success response, such

there is an opportunity to name finch to be your own representation.

MyConfiguredFinch, is it possible to make response your own representation as well and when a request is made.

%Finch.Response{} becomes %MyConfiguredFinch{}

I think this would be better handled within a module in your application. For example, you could define something like this:

defmodule MyApp.MyConfiguredFinch do
  defstruct [...fields]

  def request(request) do
    # or use a `case` if you also want to transform errors
    with {:ok, response} <- Finch.request(request, MyConfiguredFinch) do
      to_custom_response_struct(response)
    end
  end

  defp to_custom_response_struct(response) do
     %__MODULE__{...}
  end
end
keathley

comment created time in 3 months