Hello, world!

failed to obtain in-memory shard lock

joonsei — Wed, 21 Dec 2022 17:59:37 +0900

문제 발생

샤드 할당에 대한 메모리 내 잠금(OpenSearch Service에 설정된 임계값 이내)을 얻지 못하면 다음과 같은 오류 메시지

해결 방법

노란색 클러스터 상태 문제 해결

클러스터가 노란색 상태로 전환되도록 하는 인덱스를 식별하려면 다음 쿼리를 사용

curl -XGET "localhost:9200/_cat/indices?v&health=yellow"

그런 다음 클러스터 할당되지 않은 샤드의 근본 원인을 확인하려면 다음 쿼리 사용

curl -XGET "localhost:9200/_cluster/allocation/explain"

최대 재시도 설정 늘리기

클러스터를 녹색 상태로 되돌리려면 각 노란색 인덱스의 최대 재시도 횟수를 늘립니다.

curl -XPUT "localhost:9200/<yellow-index-name>/_settings" -H 'Content-Type: application/json' -d '
{
    "index.allocation.max_retries": 10
}
'

게임 마케팅 용어 정리

joonsei — Thu, 15 Dec 2022 19:42:44 +0900

[유저관련 지표]

UV	Unique visitor	게임의 접속한 실제 유저 수, 여러번 방문해도 1로 카운트
DAU	Daily Active User	일단위로 측정한 UV
WAU	Week Active User	주단위로 측정한 UV
MAU	Monthly Active User	월 단위로 UV 측정
RU	Registered User	일정기간내에 게임에 등록된 유저 수
NRU	New Registered User	일정기간내에 등록된 신규 유저 수
ARU	Accumulate Register User	해당 기간까지의 등록된 누적 유저 수
MUV	Multigame Unique Visitor	해당 기간 동안 게임 로그인하여 실제 게임을 플레이 한 회원 수
MTS	Mutigame Time Spent	해당 기간 동안의 평균 실제 플레이 타임
TS	Time Spent	해당기간 동안의 유저1인당 플레이 타임
CCU	Concurrent User	특정 시점에 접속한 동시 접속자 수
MCU	Maxium Concurrent User	하루 동안 가장 높은 동시접속자 수치
PCU	Peak Concurrent User	MCU 동일어
ACU	Average Concurrent User	1일 동안의 평균 동시 접속자 수
Stickness	Stickness	고착도

[매출 관련 지표]

BU	Buying user	구매유저, 일정기간내에 게임에 아이템 구매, 월정액 결제 등 돈을 지불한 유저
PU	Paying User	BU 동일어
BU rate	BU/UV	순방문자대비 결제 유저 비율
CAC	Customer Acquisition Cost	유저 확보 비용으로 유저 1인을 확보하는데 소모되는 비용
CRC	Customer Retention Cost	유저 유지 비용으로 일정기간내에 유저1인을 유지하는데 소모되는 비용
ARPU	Average Revenue Per User	일정 기간 내 유저 1인당 평균 수입
ARPPU	Average Revenue Per Paying User	일정 기간내에 게임에 비용을 지불한 유저의 1인당 평균 수입
PPU	Percentage of Paying Users	DAU 내에서 결제한 비율 또는 비율
LTV	Life time value	유저 1인당 게임에서 완전히 이탈할 때까지 지불하는 비용
Entry Cost	Entry Cost	여러 가지 가격대의 상품을 제공할 때 유저의 최초 구매가 어떤 가격대에서 많이 일어나는지 측정
Sales by Purchase	Sales by Purchase	사용자의 구매 활동을 통해 집계된 매출
Sales by Advertisement	Sales by Advertisement	광고 노출을 통해 집계된 매출
CPI	Cost per Install	게임 다운로드 후 설치하면 보상
CPA	Cost per Action	설치된 앱을 실행하면 보상
CPP	Cost per Play	CPA 이후 일정 기간 한번씩 실행할 때마다 보상
CPL	Cost per Level	정량적인 플레이에 대한 레벨을 설정한 뒤 보상

Elasticsearch Dynamic Templates

joonsei — Tue, 6 Dec 2022 13:22:02 +0900

Dynamic mapping

색인 필드의 데이터에 대한 data type을 지정하지 않고 동적으로 elasticsearch 에서 적절한 type을 지정해 주는 기능
mapping type을 미리 선언하지 않고 패턴이나 분석 특성에 맞춰 구성.

match_mapping_type

JSON 파서를 통해서 data type 을 detection 합니다.
long, double 의 경우 integer 와 float 에 대한 정확한 detection 이 어렵기 때문에 항상 long 과 double 로 detection

match_pattern

이 설정은 위에서 "match": "s_*" 과 같은 wildcard 패턴을 java 정규식으로 사용하기 위한 설정

[ ▼ 데이터 필드명의 prefix 값으로, 데이터 타입을 dynamic type 으로 사용하는 설정 ]

curl -XPUT "localhost:9200/_template/<indexName>?pretty" -H 'Content-Type: application/json' -d' {
    "index_patterns": [
        "<indexName>"
    ],
    "settings": {
        "number_of_shards": 1
    },
    "mappings": {
        "dynamic_templates": [
            {
                "integers": {
                    "match": "i_*",
                    "match_mapping_type": "*",
                    "mapping": {
                        "type": "integer"
                    }
                }
            },
            {
                "doubles": {
                    "match": "d_*",
                    "match_mapping_type": "*",
                    "mapping": {
                        "type": "double"
                    }
                }
            },
            {
                "floats": {
                    "match": "f_*",
                    "match_mapping_type": "*",
                    "mapping": {
                        "type": "float"
                    }
                }
            },
            {
                "booleans": {
                    "match": "b_*",
                    "match_mapping_type": "*",
                    "mapping": {
                        "type": "boolean"
                    }
                }
            },
            {
                "longs": {
                    "match": "l_*",
                    "match_mapping_type": "*",
                    "mapping": {
                        "type": "long"
                    }
                }
            },
            {
                "dates": {
                    "match": "date",
                    "match_mapping_type": "*",
                    "mapping": {
                        "type": "date"
                    }
                }
            },
            {
                "objects": {
                    "match": "o_*",
                    "match_mapping_type": "*",
                    "mapping": {
                        "type": "object"
                    }
                }
            },
            {
                "nesteds": {
                    "match": "n_*",
                    "match_mapping_type": "*",
                    "mapping": {
                        "type": "object"
                    }
                }
            },
            {
                "strings": {
                    "match": "s_*",
                    "match_mapping_type": "*",
                    "mapping": {
                        "type": "text",
                        "fields": {
                            "raw": {
                                "type": "keyword",
                                "ignore_above": 256
                            }
                        }
                    }
                }
            },
            {
                "no_integers": {
                    "match": "xi_*",
                    "mapping": {
                        "type": "integer",
                        "index": false
                    }
                }
            },
            {
                "no_doubles": {
                    "match": "xd_*",
                    "mapping": {
                        "type": "double",
                        "index": false
                    }
                }
            },
            {
                "no_floats": {
                    "match": "xf_*",
                    "mapping": {
                        "type": "float",
                        "index": false
                    }
                }
            },
            {
                "no_booleans": {
                    "match": "xb_*",
                    "mapping": {
                        "type": "boolean",
                        "index": false
                    }
                }
            },
            {
                "no_longs": {
                    "match": "xl_*",
                    "mapping": {
                        "type": "long",
                        "index": false
                    }
                }
            },
            {
                "no_dates": {
                    "match": "xdate",
                    "mapping": {
                        "type": "date",
                        "index": false
                    }
                }
            },
            {
                "no_objects": {
                    "match": "xo_*",
                    "mapping": {
                        "type": "object"
                    }
                }
            },
            {
                "no_nesteds": {
                    "match": "xn_*",
                    "mapping": {
                        "type": "nested"
                    }
                }
            },
            {
                "no_strings": {
                    "match": "xs_*",
                    "mapping": {
                        "type": "text",
                        "index": false
                    }
                }
            }
        ]
    },
    "aliases": {}
} '

Elasticsearch function_score 스코어 계산

joonsei — Wed, 9 Nov 2022 11:43:57 +0900

검색 정확도 기준

BM25 알고리즘을 이용해 문서에 대한 score 계산

TF (Term Frequency)

문서 내에서 자주 등장하는 단어(Term) 에 가중치를 높게 부여,
문서내에서 같은 단어가 여러번 등장한다면 그 단어에 높은 가중치를 주는 알고리즘

IDF (Inverse Document Frequency)

많은 문서에서 등장하는 단어의 가중치는 낮추고, 일부 문서에만 등장하는 단어에 대해 높은 가중치 부여
전체 문서에서 발생한 term 빈도수가 작을수록 weight가 높다. 문서에 자주 등장하는 단어일수록 낮은 가중치를 주는 알고리즘
똑같이 1번 검색이 되었다 하더라도 문서에 자주 등장한 단어가 매칭된 키워드일수록 낮은 가중치
문서에 많이 나오는게 좋은게 아닌가? 라고 생각할 수 있겠지만
문서에 공통적으로 많이 등장하는 단어는 실제 우리가 쓰는 단어로 살펴본다면 "은", "는", "다"처럼 형용사, 부사등이 되며 이는 실제로 큰 의미를 가지지 않을 확률이 높음

FLN (Field-Length Norm)

두개 이상의 문서에서 동일한 키워드가 동일한 빈도수로 등장한다고 가정할 때, 문서의 길이가 작은 문서에 더 높은 가중치를 부여

function_score 쿼리

검색 필드를 부스팅하여 스코어를 조정하는것은 한계가 있음.
function_score 를 통하여 좀더 디테일하고 deep한 스코어링을 조절할 수 있음.

ex)
1. 상품 검색 시, 주문 수가 많은 제품에 가중치를 부여
2. 인스타그램의 해시태그 검색 시, 좋아요 수에 가중치를 부여 (인기 게시물)

[▼ 180일 이후 게시물에 가중치를 낮게 부여하고, 추천수가 높은 게시물에 가중치를 두어 검색 정확도 커스텀]

GET my-index/_search
{
  "profile": true,
  "track_scores": true,
  "track_total_hits": true,
  "size": 1000,
  "query": {
    "function_score": {
      "functions": [
        {
          "gauss": {
            "reg_date": {
              "origin": "now",
              "scale": "180d",
              "offset": "180d",
              "decay": 0.5
            }
          }
        }
      ],
      "query": {
        "bool": {
          "must": [],
          "should": [
            {
              "range": {
                "recommend_count": {
                  "gte": 1,
                  "boost": 3
                }
              }
            },
            {
              "multi_match": {
                "query": "던전 공략",
                "fields": [
                  "title"
                ],
                "operator": "and"
              }
            }
          ]
        }
      }
    }
  }
}

index illegal_argument_exception

joonsei — Thu, 30 Jun 2022 11:59:56 +0900

Elasticsearch 에서 Index 삭제 시, Wildcard 로 요청하면,
--> Wildcard expressions or all indices are not allowed 에러가 발생하면서 삭제가 안됨.

curl -XDELETE "localhost:9200/<indexName*>"
{
  "error" : {
    "root_cause" : [
      {
        "type" : "illegal_argument_exception",
        "reason" : "Wildcard expressions or all indices are not allowed"
      }
    ],
    "type" : "illegal_argument_exception",
    "reason" : "Wildcard expressions or all indices are not allowed"
  },
  "status" : 400
}

Elasticsaearch 의 action.destructive_requires_name 값을 false 로 바꿔줘야함.

curl -XPUT "localhost:9200/_cluster/settings" -H 'Content-Type: application/json' -d '
{
  "transient": {
	"action.destructive_requires_name":false
  }
}
'


curl -XDELETE "localhost:9200/<indexName*>"
{
  "acknowledged": true
}

Document 데이터 전체 수정

joonsei — Tue, 17 May 2022 12:33:46 +0900

# 게시판 카테고리 값이 없는 데이터 일괄로 "기타"값으로 수정
curl -XPOST "localhost:9200/board-202205/_update_by_query" -H 'Content-Type: application/json' -d '
{
  "script": {
    "source": "ctx._source.category='기타'",
    "lang": "painless"
  },
  "query": {
    "bool": {
      "must_not": [
        {"exists": {"field": "category"}}
      ]
    }
  }
}
'

조건에 따른 특정 Document 데이터 수정

joonsei — Tue, 17 May 2022 10:37:43 +0900

# 1343번 게시글 카테고리를 "etc"로 수정
curl -XPOST "localhost:9200/board-202205/_update/1343" -H 'Content-Type: application/json' -d '
{
    "doc": {
        "category": "etc"
    }
}
'

조건에 따른 특정 Document 데이터 삭제

joonsei — Tue, 17 May 2022 10:36:51 +0900

# 1341번 게시글 삭제
curl -XPOST "localhost:9200/board-202205/_delete_by_query" -H 'Content-Type: application/json' -d '
{
    "query": {
        "match": {
            "_id": "1341"
        }
    }
}
'

# writer 필드가 없는 게시글 일괄 삭제
curl -XPOST "localhost:9200/board-202205/_delete_by_query" -H 'Content-Type: application/json' -d '
{
  "query": {
    "bool": {
      "must_not": {
        "exists": {
          "field": "writer"
        }
      }
    }
  }
}
'

몽고디비 컬렉션 전체 삭제하기

joonsei — Tue, 17 May 2022 10:22:16 +0900

시스템 관련 컬렉션을 제외한 전체 컬렉션 삭제하기

var dbs = db.getMongo().getDBNames();
for(var i in dbs){
    db = db.getMongo().getDB( dbs[i] );
    if (db.getName() !== 'admin' && db.getName() !== 'local'){
        print( "dropping db " + db.getName() );  
        db.dropDatabase();
    }
}

nodejs ejs render 대신 html 사용하기

joonsei — Wed, 12 Aug 2020 16:49:34 +0900

- app.js

// 화면 engine을 ejs로 설정
app.set('view engine', 'ejs');
app.engine('html', require('ejs').renderFile);

- index.js

const express = require('express');
const router = express.Router();

/* GET home page. */
router.get('/', function(req, res, next) { 
    return res.render('index.html'); 
});

module.exports = router;