Page MenuHomePhorge

No OneTemporary

Size
11 KB
Referenced Files
None
Subscribers
None
diff --git a/lib/pleroma/search/elasticsearch/document_mappings/activity.ex b/lib/pleroma/search/elasticsearch/document_mappings/activity.ex
index edd8e03c1..3a84e991b 100644
--- a/lib/pleroma/search/elasticsearch/document_mappings/activity.ex
+++ b/lib/pleroma/search/elasticsearch/document_mappings/activity.ex
@@ -1,55 +1,61 @@
# Akkoma: A lightweight social networking server
# Copyright © 2022-2022 Akkoma Authors <https://git.ihatebeinga.live/IHBAGang/akkoma/>
# SPDX-License-Identifier: AGPL-3.0-only
defimpl Elasticsearch.Document, for: Pleroma.Activity do
alias Pleroma.Object
require Pleroma.Constants
def id(obj), do: obj.id
def routing(_), do: false
def object_to_search_data(object) do
# Only index public or unlisted Notes
if not is_nil(object) and object.data["type"] == "Note" and
not is_nil(object.data["content"]) and
(Pleroma.Constants.as_public() in object.data["to"] or
Pleroma.Constants.as_public() in object.data["cc"]) and
String.length(object.data["content"]) > 1 do
data = object.data
content_str =
case data["content"] do
[nil | rest] -> to_string(rest)
str -> str
end
content =
with {:ok, scrubbed} <- FastSanitize.strip_tags(content_str),
trimmed <- String.trim(scrubbed) do
trimmed
end
if String.length(content) > 1 do
{:ok, published, _} = DateTime.from_iso8601(data["published"])
%{
_timestamp: published,
content: content,
instance: URI.parse(object.data["actor"]).host,
hashtags: Object.hashtags(object),
user: Pleroma.User.get_cached_by_ap_id(object.data["actor"]).nickname
}
else
%{}
end
else
%{}
end
end
def encode(activity) do
object = Pleroma.Object.normalize(activity)
object_to_search_data(object)
end
end
+
+defimpl Elasticsearch.Document, for: Pleroma.Object do
+ def id(obj), do: obj.id
+ def routing(_), do: false
+ def encode(_), do: nil
+end
diff --git a/lib/pleroma/telemetry/logger.ex b/lib/pleroma/telemetry/logger.ex
index 35e245237..50f7fcf2a 100644
--- a/lib/pleroma/telemetry/logger.ex
+++ b/lib/pleroma/telemetry/logger.ex
@@ -1,156 +1,95 @@
# Pleroma: A lightweight social networking server
# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Telemetry.Logger do
@moduledoc "Transforms Pleroma telemetry events to logs"
require Logger
@events [
[:pleroma, :connection_pool, :reclaim, :start],
[:pleroma, :connection_pool, :reclaim, :stop],
[:pleroma, :connection_pool, :provision_failure],
[:pleroma, :connection_pool, :client, :dead],
- [:pleroma, :connection_pool, :client, :add],
- [:pleroma, :repo, :query]
+ [:pleroma, :connection_pool, :client, :add]
]
def attach do
:telemetry.attach_many(
"pleroma-logger",
@events,
&Pleroma.Telemetry.Logger.handle_event/4,
[]
)
end
# Passing anonymous functions instead of strings to logger is intentional,
# that way strings won't be concatenated if the message is going to be thrown
# out anyway due to higher log level configured
def handle_event(
[:pleroma, :connection_pool, :reclaim, :start],
_,
%{max_connections: max_connections, reclaim_max: reclaim_max},
_
) do
Logger.debug(fn ->
"Connection pool is exhausted (reached #{max_connections} connections). Starting idle connection cleanup to reclaim as much as #{reclaim_max} connections"
end)
end
def handle_event(
[:pleroma, :connection_pool, :reclaim, :stop],
%{reclaimed_count: 0},
_,
_
) do
Logger.error(fn ->
"Connection pool failed to reclaim any connections due to all of them being in use. It will have to drop requests for opening connections to new hosts"
end)
end
def handle_event(
[:pleroma, :connection_pool, :reclaim, :stop],
%{reclaimed_count: reclaimed_count},
_,
_
) do
Logger.debug(fn -> "Connection pool cleaned up #{reclaimed_count} idle connections" end)
end
def handle_event(
[:pleroma, :connection_pool, :provision_failure],
%{opts: [key | _]},
_,
_
) do
Logger.error(fn ->
"Connection pool had to refuse opening a connection to #{key} due to connection limit exhaustion"
end)
end
def handle_event(
[:pleroma, :connection_pool, :client, :dead],
%{client_pid: client_pid, reason: reason},
%{key: key},
_
) do
Logger.warn(fn ->
"Pool worker for #{key}: Client #{inspect(client_pid)} died before releasing the connection with #{inspect(reason)}"
end)
end
def handle_event(
[:pleroma, :connection_pool, :client, :add],
%{clients: [_, _ | _] = clients},
%{key: key, protocol: :http},
_
) do
Logger.info(fn ->
"Pool worker for #{key}: #{length(clients)} clients are using an HTTP1 connection at the same time, head-of-line blocking might occur."
end)
end
def handle_event([:pleroma, :connection_pool, :client, :add], _, _, _), do: :ok
-
- def handle_event(
- [:pleroma, :repo, :query] = _name,
- %{query_time: query_time} = measurements,
- %{source: source} = metadata,
- config
- ) do
- logging_config = Pleroma.Config.get([:telemetry, :slow_queries_logging], [])
-
- if logging_config[:enabled] &&
- logging_config[:min_duration] &&
- query_time > logging_config[:min_duration] and
- (is_nil(logging_config[:exclude_sources]) or
- source not in logging_config[:exclude_sources]) do
- log_slow_query(measurements, metadata, config)
- else
- :ok
- end
- end
-
- defp log_slow_query(
- %{query_time: query_time} = _measurements,
- %{source: _source, query: query, params: query_params, repo: repo} = _metadata,
- _config
- ) do
- sql_explain =
- with {:ok, %{rows: explain_result_rows}} <-
- repo.query("EXPLAIN " <> query, query_params, log: false) do
- Enum.map_join(explain_result_rows, "\n", & &1)
- end
-
- {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)
-
- pleroma_stacktrace =
- Enum.filter(stacktrace, fn
- {__MODULE__, _, _, _} ->
- false
-
- {mod, _, _, _} ->
- mod
- |> to_string()
- |> String.starts_with?("Elixir.Pleroma.")
- end)
-
- Logger.warn(fn ->
- """
- Slow query!
-
- Total time: #{round(query_time / 1_000)} ms
-
- #{query}
-
- #{inspect(query_params, limit: :infinity)}
-
- #{sql_explain}
-
- #{Exception.format_stacktrace(pleroma_stacktrace)}
- """
- end)
- end
end
diff --git a/test/pleroma/search/database_search_test.ex b/test/pleroma/search/database_search_test.exs
similarity index 100%
rename from test/pleroma/search/database_search_test.ex
rename to test/pleroma/search/database_search_test.exs
diff --git a/test/pleroma/search/elasticsearch_test.exs b/test/pleroma/search/elasticsearch_test.exs
new file mode 100644
index 000000000..cc5eb6792
--- /dev/null
+++ b/test/pleroma/search/elasticsearch_test.exs
@@ -0,0 +1,120 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Search.ElasticsearchTest do
+ require Pleroma.Constants
+
+ use Pleroma.DataCase
+ use Oban.Testing, repo: Pleroma.Repo
+
+ import Pleroma.Factory
+ import Tesla.Mock
+ import Mock
+
+ alias Pleroma.Web.CommonAPI
+ alias Pleroma.Workers.SearchIndexingWorker
+
+ describe "elasticsearch" do
+ setup do
+ clear_config([Pleroma.Search, :module], Pleroma.Search.Elasticsearch)
+ clear_config([Pleroma.Search.Elasticsearch.Cluster, :api], Pleroma.ElasticsearchMock)
+ end
+
+ setup_with_mocks(
+ [
+ {Pleroma.Search.Elasticsearch, [:passthrough],
+ [
+ add_to_index: fn a -> passthrough([a]) end,
+ remove_from_index: fn a -> passthrough([a]) end
+ ]},
+ {Elasticsearch, [:passthrough],
+ [
+ put_document: fn _, _, _ -> :ok end,
+ delete_document: fn _, _, _ -> :ok end
+ ]}
+ ],
+ context,
+ do: {:ok, context}
+ )
+
+ test "indexes a local post on creation" do
+ user = insert(:user)
+
+ {:ok, activity} =
+ CommonAPI.post(user, %{
+ status: "guys i just don't wanna leave the swamp",
+ visibility: "public"
+ })
+
+ args = %{"op" => "add_to_index", "activity" => activity.id}
+
+ assert_enqueued(
+ worker: SearchIndexingWorker,
+ args: args
+ )
+
+ assert :ok = perform_job(SearchIndexingWorker, args)
+
+ assert_called(Pleroma.Search.Elasticsearch.add_to_index(activity))
+ end
+
+ test "doesn't index posts that are not public" do
+ user = insert(:user)
+
+ Enum.each(["private", "direct"], fn visibility ->
+ {:ok, activity} =
+ CommonAPI.post(user, %{
+ status: "guys i just don't wanna leave the swamp",
+ visibility: visibility
+ })
+
+ args = %{"op" => "add_to_index", "activity" => activity.id}
+
+ assert_enqueued(worker: SearchIndexingWorker, args: args)
+ assert :ok = perform_job(SearchIndexingWorker, args)
+
+ assert_not_called(Elasticsearch.put_document(:_))
+ end)
+
+ history = call_history(Pleroma.Search.Elasticsearch)
+ assert Enum.count(history) == 2
+ end
+
+ test "deletes posts from index when deleted locally" do
+ user = insert(:user)
+
+ mock_global(fn
+ %{method: :put, url: "http://127.0.0.1:7700/indexes/objects/documents", body: body} ->
+ assert match?(
+ [%{"content" => "guys i just don&#39;t wanna leave the swamp"}],
+ Jason.decode!(body)
+ )
+
+ json(%{updateId: 1})
+
+ %{method: :delete, url: "http://127.0.0.1:7700/indexes/objects/documents/" <> id} ->
+ assert String.length(id) > 1
+ json(%{updateId: 2})
+ end)
+
+ {:ok, activity} =
+ CommonAPI.post(user, %{
+ status: "guys i just don't wanna leave the swamp",
+ visibility: "public"
+ })
+
+ args = %{"op" => "add_to_index", "activity" => activity.id}
+ assert_enqueued(worker: SearchIndexingWorker, args: args)
+ assert :ok = perform_job(SearchIndexingWorker, args)
+
+ {:ok, _} = CommonAPI.delete(activity.id, user)
+
+ delete_args = %{"op" => "remove_from_index", "object" => activity.object.id}
+ assert_enqueued(worker: SearchIndexingWorker, args: delete_args)
+ assert :ok = perform_job(SearchIndexingWorker, delete_args)
+
+ assert_called(Pleroma.Search.Elasticsearch.remove_from_index(:_))
+ end
+ end
+end
diff --git a/test/support/elasticsearch_mock.ex b/test/support/elasticsearch_mock.ex
new file mode 100644
index 000000000..6e203f2ef
--- /dev/null
+++ b/test/support/elasticsearch_mock.ex
@@ -0,0 +1,14 @@
+defmodule Pleroma.ElasticsearchMock do
+ @behaviour Elasticsearch.API
+
+ @impl true
+ def request(_config, :get, "/posts/1", _data, _opts) do
+ {:ok,
+ %HTTPoison.Response{
+ status_code: 404,
+ body: %{
+ "status" => "not_found"
+ }
+ }}
+ end
+end

File Metadata

Mime Type
text/x-diff
Expires
Sun, Aug 9, 7:57 AM (1 d, 16 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
1724344
Default Alt Text
(11 KB)

Event Timeline