Remove stdlib2

.gitignore

@@ -1,3 +1,6 @@
+*~
 .*
 /deps/
 /ebin/
+/_build
+rebar.lock

Makefile

@@ -1,7 +1,7 @@
 PROJECT = raven
 
 DIALYZER = dialyzer
-REBAR = rebar
+REBAR = rebar3
 
 all: app
 

rebar.config

@@ -1,10 +1,17 @@
 %% -*- mode: erlang;erlang-indent-level: 4;indent-tabs-mode: nil -*-
 %% ex: ts=4 sw=4 noet syntax=erlang
-{erl_opts, [
-	warnings_as_errors,
-	warn_export_all,
-	{platform_define, "^R14", no_callbacks}
-]}.
-{deps, [
-	{jiffy, ".*", {git, "git://github.com/davisp/jiffy.git", {tag, "0.13.1"}}}
-]}.
+{erl_opts, [ warnings_as_errors,
+             warn_export_all,
+             {platform_define, "^R14", no_callbacks}
+           ]
+}.
+
+{deps, [ {jsx, ".*", {git, "[email protected]:kivra/jsx.git",     {tag, "2.9.0"}}} ]
+}.
+
+{profiles, [ {test, [ {deps, [ {meck, {git, "[email protected]:kivra/meck.git", {tag, "0.8.13"}}}]},
+                      {extra_src_dirs, [{"test", [{recursive, true}]}]}
+                    ]
+             }
+           ]
+}.

src/raven.app.src

@@ -8,8 +8,7 @@
 		crypto,
 		public_key,
 		ssl,
-		inets,
-		jiffy
+		inets
 	]},
 	{mod, {raven_app, []}},
 	{env, [

src/raven.erl

@@ -1,17 +1,22 @@
 -module(raven).
 -export([
 	capture/2,
+	capture_prepare/2,
+	capture_with_backoff_send/2,
 	user_agent/0
 ]).
 
+-include("raven.hrl").
+
 -define(SENTRY_VERSION, "2.0").
 
 -record(cfg, {
 	uri :: string(),
 	public_key :: string(),
 	private_key :: string(),
 	project :: string(),
-	ipfamily :: atom()
+	ipfamily :: atom(),
+	release :: binary() | undefined
 }).
 
 -type cfg_rec() :: #cfg{}.
@@ -27,34 +32,61 @@
 capture(Message, Params) when is_list(Message) ->
 	capture(unicode:characters_to_binary(Message), Params);
 capture(Message, Params) ->
+	{ok, Body} = capture_prepare(Message, Params),
+	capture_with_backoff_send(Body, false).
+
+capture_prepare(Message, Params) ->
 	Cfg = get_config(),
-	Document = {[
+	Document = [
 		{event_id, event_id_i()},
 		{project, unicode:characters_to_binary(Cfg#cfg.project)},
 		{platform, erlang},
 		{server_name, node()},
 		{timestamp, timestamp_i()},
+		{release, Cfg#cfg.release},
 		{message, term_to_json_i(Message)} |
 		lists:map(fun
 			({stacktrace, Value}) ->
-				{'sentry.interfaces.Stacktrace', {[
+				{'sentry.interfaces.Stacktrace', [
 					{frames,lists:reverse([frame_to_json_i(Frame) || Frame <- Value])}
-				]}};
+				]};
 			({exception, {Type, Value}}) ->
-				{'sentry.interfaces.Exception', {[
-					{type, Type},
+				{'sentry.interfaces.Exception', [
+					{type, term_to_json_i(Type)},
+					{value, term_to_json_i(Value)}
+				]};
+			({exception, Value}) ->
+				{'sentry.interfaces.Exception', [
+					{type, error},
 					{value, term_to_json_i(Value)}
-				]}};
+				]};
+			({http_request, {Method, Url, Headers}}) ->
+				{'sentry.interfaces.Http', [
+					{method,  Method},
+					{url,     Url},
+					{headers, Headers}
+				]};
+			% Reserved keys are 'id', 'username', 'email' and 'ip_address' out
+			% of which ONE needs to be supplied. Additional arbitrary keys may
+			% also be sent.
+			({user, KVs}) when is_list(KVs) ->
+				{'sentry.interfaces.User', KVs};
 			({tags, Tags}) ->
-				{tags, {[{Key, term_to_json_i(Value)} || {Key, Value} <- Tags]}};
+				{tags, [{Key, term_to_json_i(Value)} || {Key, Value} <- Tags]};
 			({extra, Tags}) ->
-				{extra, {[{Key, term_to_json_i(Value)} || {Key, Value} <- Tags]}};
+				{extra, [{Key, term_to_json_i(Value)} || {Key, Value} <- Tags]};
 			({Key, Value}) ->
 				{Key, term_to_json_i(Value)}
 		end, Params)
-	]},
+	],
+	Body = base64:encode(zlib:compress(jsx:encode(Document))),
+	{ok, Body}.
+
+%Synchronized set to true returns backoff
+%otherwise, it is not returned
+capture_with_backoff_send(Body, Synchronized) ->
+	Cfg = get_config(),
 	Timestamp = integer_to_list(unix_timestamp_i()),
-	Body = base64:encode(zlib:compress(jiffy:encode(Document, [force_utf8]))),
 	UA = user_agent(),
 	Headers = [
 		{"X-Sentry-Auth",
@@ -65,18 +97,39 @@ capture(Message, Params) ->
 		{"User-Agent", UA}
 	],
 	ok = httpc:set_options([{ipfamily, Cfg#cfg.ipfamily}]),
-	httpc:request(post,
+	{ok, Result} = httpc:request(post,
 		{Cfg#cfg.uri ++ "/api/store/", Headers, "application/octet-stream", Body},
-		[],
-		[{body_format, binary}, {sync, false}]
+		[ssl_options()],
+		[{body_format, binary}, {sync, Synchronized}],
+        ?RAVEN_HTTPC_PROFILE
 	),
-	ok.
+	case Synchronized of
+		false -> ok;
+		true  -> {ok, extract_backoff(Result)}
+	end.
+
+extract_backoff(Result)  when is_reference(Result) ->
+	io:format("~nHTTP return was reference ~p~n", [Result]),
+	0;
+extract_backoff({StatusLine, Headers, _Body}) ->
+	{_,ResponseCode, _} = StatusLine,
+	case ResponseCode of
+		429 ->
+			Backoff = list_to_integer(proplists:get_value("retry-after", Headers)),
+			io:format("       retry:  ~p~n", [Backoff]),
+			Backoff;
+		_   ->
+			0
+	end.
 
 -spec user_agent() -> iolist().
 user_agent() ->
 	{ok, Vsn} = application:get_key(raven, vsn),
 	["raven-erlang/", Vsn].
 
+ssl_options() ->
+    persistent_term:get(?RAVEN_SSL_PERSIST_KEY).
+
 %% @private
 -spec get_config() -> cfg_rec().
 get_config() ->
@@ -85,6 +138,7 @@ get_config() ->
 -spec get_config(App :: atom()) -> cfg_rec().
 get_config(App) ->
 	{ok, IpFamily} = application:get_env(App, ipfamily),
+	Release = application:get_env(App, release, undefined),
 	case application:get_env(App, dsn) of
 		{ok, Dsn} ->
 			{match, [_, Protocol, PublicKey, SecretKey, Uri, Project]} =
@@ -93,7 +147,8 @@ get_config(App) ->
 			     public_key = PublicKey,
 			     private_key = SecretKey,
 			     project = Project,
-			     ipfamily = IpFamily};
+			     ipfamily = IpFamily,
+			     release = Release};
 		undefined ->
 			{ok, Uri} = application:get_env(App, uri),
 			{ok, PublicKey} = application:get_env(App, public_key),
@@ -103,16 +158,17 @@ get_config(App) ->
 			     public_key = PublicKey,
 			     private_key = PrivateKey,
 			     project = Project,
-			     ipfamily = IpFamily}
+			     ipfamily = IpFamily,
+			     release = Release}
 	end.
 
 
 event_id_i() ->
-	U0 = crypto:rand_uniform(0, (2 bsl 32) - 1),
-	U1 = crypto:rand_uniform(0, (2 bsl 16) - 1),
-	U2 = crypto:rand_uniform(0, (2 bsl 12) - 1),
-	U3 = crypto:rand_uniform(0, (2 bsl 32) - 1),
-	U4 = crypto:rand_uniform(0, (2 bsl 30) - 1),
+	U0 = rand:uniform((2 bsl 32) - 1) - 1,
+	U1 = rand:uniform((2 bsl 16) - 1) - 1,
+	U2 = rand:uniform((2 bsl 12) - 1) - 1,
+	U3 = rand:uniform((2 bsl 32) - 1) - 1,
+	U4 = rand:uniform((2 bsl 30) - 1) - 1,
 	<<UUID:128>> = <<U0:32, U1:16, 4:4, U2:12, 2#10:2, U3:32, U4:30>>,
 	iolist_to_binary(io_lib:format("~32.16.0b", [UUID])).
 
@@ -136,7 +192,6 @@ frame_to_json_i({Module, Function, Arguments, Location}) ->
 		false -> -1;
 		{line, L} -> L
 	end,
-	{
 		case is_list(Arguments) of
 			true -> [{vars, [iolist_to_binary(io_lib:format("~w", [Argument])) || Argument <- Arguments]}];
 			false -> []
@@ -148,10 +203,9 @@ frame_to_json_i({Module, Function, Arguments, Location}) ->
 				false -> <<(atom_to_binary(Module, utf8))/binary, ".erl">>;
 				{file, File} -> list_to_binary(File)
 			end}
-		]
-	}.
+		].
 
 term_to_json_i(Term) when is_binary(Term); is_atom(Term) ->
 	Term;
 term_to_json_i(Term) ->
-	iolist_to_binary(io_lib:format("~120p", [Term])).
+	iolist_to_binary(raven_io:format("~120p", [Term])).

src/raven.hrl

@@ -0,0 +1,7 @@
+
+%% The httpc profile used by raven
+-define(RAVEN_HTTPC_PROFILE, raven).
+
+%% Key of persistent term for httpc ssl options
+-define(RAVEN_SSL_PERSIST_KEY, {raven, ssl}).
+

src/raven_app.erl

@@ -10,6 +10,8 @@
 	stop/1
 ]).
 
+-include("raven.hrl").
+
 -spec start() -> ok | {error, term()}.
 start() ->
 	ensure_started(raven).
@@ -21,13 +23,39 @@ stop() ->
 
 %% @hidden
 start(_StartType, _StartArgs) ->
+    case application:get_env(ssl) of
+        {ok, Options} ->
+            persistent_term:put(?RAVEN_SSL_PERSIST_KEY, {ssl, Options});
+        _ ->
+            logger:notice("Raven not configured with httpc ssl options"),
+            persistent_term:put(?RAVEN_SSL_PERSIST_KEY, {ssl, []})
+    end,
+    {ok, _ProfilePid} = inets:start(httpc, [{profile, ?RAVEN_HTTPC_PROFILE}]),
 	case application:get_env(uri) of
 		{ok, _} ->
 			case application:get_env(error_logger) of
-				{ok, true} -> error_logger:add_report_handler(raven_error_logger);
+				{ok, true} ->
+					error_logger:add_report_handler(raven_error_logger);
 				_ -> ok
 			end,
-			raven_sup:start_link();
+			case application:get_env(otp_logger) of
+				{ok, true} ->
+					logger:add_handler(raven_otp_logger, raven_logger_backend, #{level => warning
+						, filter_default => log
+						, filters => [{ssl,      {fun logger_filters:domain/2, {stop, sub, [ssl]}}}
+									 ,{progress, {fun logger_filters:domain/2, {stop, equal, [progress]}}}
+									 ,{raven,    {fun logger_filters:domain/2, {stop, sub, [raven]}}}
+						             ,{sasl,     {fun logger_filters:domain/2, {stop, sub, [otp, sasl]}}}
+									 ]});
+				_ ->
+					ok
+			end,
+			case raven_sup:start_link() of
+				{ok, Pid} ->
+					{ok, Pid};
+				Error ->
+					Error
+			end;
 		_ ->
 			{error, missing_configuration}
 	end.
@@ -40,7 +68,9 @@ stop(_State) ->
 			ok;
 		_ ->
 			ok
-	end.
+	end,
+    inets:stop(httpc, ?RAVEN_HTTPC_PROFILE),
+    ok.
 
 %% @private
 ensure_started(App) ->